// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
#include "precomp.h"
// structs
typedef const struct _BUILT_IN_VARIABLE_DECLARATION
{
LPCWSTR wzVariable;
PFN_INITIALIZEVARIABLE pfnInitialize;
DWORD_PTR dwpInitializeData;
BOOL fPersist;
BOOL fOverridable;
} BUILT_IN_VARIABLE_DECLARATION;
typedef const struct _WELL_KNOWN_VARIABLE_DECLARATION
{
LPCWSTR wzVariable;
BOOL fPersist;
} WELL_KNOWN_VARIABLE_DECLARATION;
// constants
const DWORD GROW_VARIABLE_ARRAY = 3;
enum OS_INFO_VARIABLE
{
OS_INFO_VARIABLE_NONE,
OS_INFO_VARIABLE_VersionNT,
OS_INFO_VARIABLE_VersionNT64,
OS_INFO_VARIABLE_ServicePackLevel,
OS_INFO_VARIABLE_NTProductType,
OS_INFO_VARIABLE_NTSuiteBackOffice,
OS_INFO_VARIABLE_NTSuiteDataCenter,
OS_INFO_VARIABLE_NTSuiteEnterprise,
OS_INFO_VARIABLE_NTSuitePersonal,
OS_INFO_VARIABLE_NTSuiteSmallBusiness,
OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted,
OS_INFO_VARIABLE_NTSuiteWebServer,
OS_INFO_VARIABLE_CompatibilityMode,
OS_INFO_VARIABLE_TerminalServer,
OS_INFO_VARIABLE_ProcessorArchitecture,
OS_INFO_VARIABLE_WindowsBuildNumber,
};
enum SET_VARIABLE
{
SET_VARIABLE_NOT_BUILTIN,
SET_VARIABLE_OVERRIDE_BUILTIN,
SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS,
SET_VARIABLE_ANY,
};
// internal function declarations
static HRESULT FormatString(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzIn,
__out_z_opt LPWSTR* psczOut,
__out_opt SIZE_T* pcchOut,
__in BOOL fObfuscateHiddenVariables,
__out BOOL* pfContainsHiddenVariable
);
static HRESULT GetFormatted(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out_z LPWSTR* psczValue,
__out BOOL* pfContainsHiddenVariable
);
static HRESULT AddBuiltInVariable(
__in BURN_VARIABLES* pVariables,
__in LPCWSTR wzVariable,
__in PFN_INITIALIZEVARIABLE pfnInitialize,
__in DWORD_PTR dwpInitializeData,
__in BOOL fPersist,
__in BOOL fOverridable
);
static HRESULT AddWellKnownVariable(
__in BURN_VARIABLES* pVariables,
__in LPCWSTR wzVariable,
__in BOOL fPersisted
);
static HRESULT GetVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out BURN_VARIABLE** ppVariable
);
static HRESULT FindVariableIndexByName(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out DWORD* piVariable
);
static HRESULT InsertUserVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in DWORD iPosition
);
static HRESULT InsertVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in DWORD iPosition
);
static HRESULT SetVariableValue(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in BURN_VARIANT* pVariant,
__in SET_VARIABLE setBuiltin,
__in BOOL fLog
);
static HRESULT InitializeVariableVersionNT(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableNativeMachine(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableOsInfo(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableSystemInfo(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableComputerName(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableVersionMsi(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableCsidlFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableWindowsVolumeFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableTempFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableSystemFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariablePrivileged(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableProcessTokenPrivilege(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeSystemLanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeUserUILanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeUserLanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableString(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableNumeric(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariable6432Folder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableDate(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableInstallerName(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableInstallerVersion(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableInstallerInformationalVersion(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableVersion(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT InitializeVariableLogonUser(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
static HRESULT Get64bitFolderFromRegistry(
__in int nFolder,
__deref_out_z LPWSTR* psczPath
);
#if !defined(_WIN64)
static HRESULT InitializeVariableRegistryFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
);
#endif
// function definitions
extern "C" HRESULT VariableInitialize(
__in BURN_VARIABLES* pVariables
)
{
HRESULT hr = S_OK;
::InitializeCriticalSection(&pVariables->csAccess);
const BUILT_IN_VARIABLE_DECLARATION vrgBuiltInVariables[] = {
{L"AdminToolsFolder", InitializeVariableCsidlFolder, CSIDL_ADMINTOOLS},
{L"AppDataFolder", InitializeVariableCsidlFolder, CSIDL_APPDATA},
{L"CommonAppDataFolder", InitializeVariableCsidlFolder, CSIDL_COMMON_APPDATA},
#if defined(_WIN64)
{L"CommonFiles64Folder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMON},
{L"CommonFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMONX86},
#else
{L"CommonFiles64Folder", InitializeVariableRegistryFolder, CSIDL_PROGRAM_FILES_COMMON},
{L"CommonFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES_COMMON},
#endif
{L"CommonFiles6432Folder", InitializeVariable6432Folder, CSIDL_PROGRAM_FILES_COMMON},
{L"CompatibilityMode", InitializeVariableOsInfo, OS_INFO_VARIABLE_CompatibilityMode},
{VARIABLE_DATE, InitializeVariableDate, 0},
{L"ComputerName", InitializeVariableComputerName, 0},
{L"DesktopFolder", InitializeVariableCsidlFolder, CSIDL_DESKTOP},
{L"FavoritesFolder", InitializeVariableCsidlFolder, CSIDL_FAVORITES},
{L"FontsFolder", InitializeVariableCsidlFolder, CSIDL_FONTS},
{VARIABLE_INSTALLERNAME, InitializeVariableInstallerName, 0},
{VARIABLE_INSTALLERVERSION, InitializeVariableInstallerVersion, 0},
{VARIABLE_INSTALLERINFORMATIONALVERSION, InitializeVariableInstallerInformationalVersion, 0},
{L"LocalAppDataFolder", InitializeVariableCsidlFolder, CSIDL_LOCAL_APPDATA},
{VARIABLE_LOGONUSER, InitializeVariableLogonUser, 0},
{L"MyPicturesFolder", InitializeVariableCsidlFolder, CSIDL_MYPICTURES},
{L"NativeMachine", InitializeVariableNativeMachine, 0},
{L"NTProductType", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTProductType},
{L"NTSuiteBackOffice", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteBackOffice},
{L"NTSuiteDataCenter", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteDataCenter},
{L"NTSuiteEnterprise", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteEnterprise},
{L"NTSuitePersonal", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuitePersonal},
{L"NTSuiteSmallBusiness", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteSmallBusiness},
{L"NTSuiteSmallBusinessRestricted", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted},
{L"NTSuiteWebServer", InitializeVariableOsInfo, OS_INFO_VARIABLE_NTSuiteWebServer},
{L"PersonalFolder", InitializeVariableCsidlFolder, CSIDL_PERSONAL},
{L"Privileged", InitializeVariablePrivileged, 0},
{L"ProcessorArchitecture", InitializeVariableSystemInfo, OS_INFO_VARIABLE_ProcessorArchitecture},
#if defined(_WIN64)
{L"ProgramFiles64Folder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES},
{L"ProgramFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILESX86},
#else
{L"ProgramFiles64Folder", InitializeVariableRegistryFolder, CSIDL_PROGRAM_FILES},
{L"ProgramFilesFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAM_FILES},
#endif
{L"ProgramFiles6432Folder", InitializeVariable6432Folder, CSIDL_PROGRAM_FILES},
{L"ProgramMenuFolder", InitializeVariableCsidlFolder, CSIDL_PROGRAMS},
{VARIABLE_REBOOTPENDING, InitializeVariableNumeric, 0},
{L"SendToFolder", InitializeVariableCsidlFolder, CSIDL_SENDTO},
{L"ServicePackLevel", InitializeVariableVersionNT, OS_INFO_VARIABLE_ServicePackLevel},
{L"StartMenuFolder", InitializeVariableCsidlFolder, CSIDL_STARTMENU},
{L"StartupFolder", InitializeVariableCsidlFolder, CSIDL_STARTUP},
{L"SystemFolder", InitializeVariableSystemFolder, FALSE},
{L"System64Folder", InitializeVariableSystemFolder, TRUE},
{L"SystemLanguageID", InitializeSystemLanguageID, 0},
{L"TempFolder", InitializeVariableTempFolder, 0},
{L"TemplateFolder", InitializeVariableCsidlFolder, CSIDL_TEMPLATES},
{L"TerminalServer", InitializeVariableOsInfo, OS_INFO_VARIABLE_TerminalServer},
{L"UserUILanguageID", InitializeUserUILanguageID, 0},
{L"UserLanguageID", InitializeUserLanguageID, 0},
{L"VersionMsi", InitializeVariableVersionMsi, 0},
{L"VersionNT", InitializeVariableVersionNT, OS_INFO_VARIABLE_VersionNT},
{L"VersionNT64", InitializeVariableVersionNT, OS_INFO_VARIABLE_VersionNT64},
{L"WindowsBuildNumber", InitializeVariableVersionNT, OS_INFO_VARIABLE_WindowsBuildNumber},
{L"WindowsFolder", InitializeVariableCsidlFolder, CSIDL_WINDOWS},
{L"WindowsVolume", InitializeVariableWindowsVolumeFolder, 0},
{BURN_BUNDLE_ACTION, InitializeVariableNumeric, 0, FALSE, TRUE},
{L"WixCanRestart", InitializeVariableProcessTokenPrivilege, (DWORD_PTR)SE_SHUTDOWN_NAME},
{BURN_BUNDLE_COMMAND_LINE_ACTION, InitializeVariableNumeric, 0, FALSE, TRUE},
{BURN_BUNDLE_EXECUTE_PACKAGE_CACHE_FOLDER, InitializeVariableString, NULL, FALSE, TRUE},
{BURN_BUNDLE_EXECUTE_PACKAGE_ACTION, InitializeVariableString, NULL, FALSE, TRUE},
{BURN_BUNDLE_FORCED_RESTART_PACKAGE, InitializeVariableString, NULL, TRUE, TRUE},
{BURN_BUNDLE_INSTALLED, InitializeVariableNumeric, 0},
{BURN_BUNDLE_ELEVATED, InitializeVariableNumeric, 0, FALSE, TRUE},
{BURN_BUNDLE_ACTIVE_PARENT, InitializeVariableString, NULL, FALSE, TRUE},
{BURN_BUNDLE_PROVIDER_KEY, InitializeVariableString, (DWORD_PTR)L"", FALSE, TRUE},
{BURN_BUNDLE_TAG, InitializeVariableString, (DWORD_PTR)L"", FALSE, TRUE},
{BURN_BUNDLE_UILEVEL, InitializeVariableNumeric, 0, FALSE, TRUE},
{BURN_BUNDLE_VERSION, InitializeVariableVersion, (DWORD_PTR)L"0", FALSE, TRUE},
};
const WELL_KNOWN_VARIABLE_DECLARATION vrgWellKnownVariableNames[] =
{
{ BURN_BUNDLE_LAYOUT_DIRECTORY },
{ BURN_BUNDLE_NAME, TRUE },
{ BURN_BUNDLE_INPROGRESS_NAME, TRUE },
{ BURN_BUNDLE_LAST_USED_SOURCE, TRUE },
{ BURN_BUNDLE_MANUFACTURER, TRUE },
{ BURN_BUNDLE_ORIGINAL_SOURCE, TRUE },
{ BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER, TRUE },
};
for (DWORD i = 0; i < countof(vrgBuiltInVariables); ++i)
{
BUILT_IN_VARIABLE_DECLARATION* pBuiltInVariable = &vrgBuiltInVariables[i];
hr = AddBuiltInVariable(pVariables, pBuiltInVariable->wzVariable, pBuiltInVariable->pfnInitialize, pBuiltInVariable->dwpInitializeData, pBuiltInVariable->fPersist, pBuiltInVariable->fOverridable);
ExitOnFailure(hr, "Failed to add built-in variable: %ls.", pBuiltInVariable->wzVariable);
}
for (DWORD i = 0; i < countof(vrgWellKnownVariableNames); ++i)
{
WELL_KNOWN_VARIABLE_DECLARATION* pWellKnownVariable = &vrgWellKnownVariableNames[i];
hr = AddWellKnownVariable(pVariables, pWellKnownVariable->wzVariable, pWellKnownVariable->fPersist);
ExitOnFailure(hr, "Failed to add well-known variable: %ls.", pWellKnownVariable->wzVariable);
}
LExit:
return hr;
}
extern "C" HRESULT VariablesParseFromXml(
__in BURN_VARIABLES* pVariables,
__in IXMLDOMNode* pixnBundle
)
{
HRESULT hr = S_OK;
BOOL fXmlFound = FALSE;
IXMLDOMNodeList* pixnNodes = NULL;
IXMLDOMNode* pixnNode = NULL;
DWORD cNodes = 0;
LPWSTR sczId = NULL;
LPWSTR scz = NULL;
BURN_VARIANT value = { };
BURN_VARIANT_TYPE valueType = BURN_VARIANT_TYPE_NONE;
BOOL fHidden = FALSE;
BOOL fPersisted = FALSE;
DWORD iVariable = 0;
::EnterCriticalSection(&pVariables->csAccess);
// select variable nodes
hr = XmlSelectNodes(pixnBundle, L"Variable", &pixnNodes);
ExitOnFailure(hr, "Failed to select variable nodes.");
// get variable node count
hr = pixnNodes->get_length((long*)&cNodes);
ExitOnFailure(hr, "Failed to get variable node count.");
// parse variable elements
for (DWORD i = 0; i < cNodes; ++i)
{
hr = XmlNextElement(pixnNodes, &pixnNode, NULL);
ExitOnFailure(hr, "Failed to get next node.");
// @Id
hr = XmlGetAttributeEx(pixnNode, L"Id", &sczId);
ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Id.");
// @Hidden
hr = XmlGetYesNoAttribute(pixnNode, L"Hidden", &fHidden);
ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Hidden.");
// @Persisted
hr = XmlGetYesNoAttribute(pixnNode, L"Persisted", &fPersisted);
ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Persisted.");
// @Value
hr = XmlGetAttributeEx(pixnNode, L"Value", &scz);
ExitOnOptionalXmlQueryFailure(hr, fXmlFound, "Failed to get @Value.");
if (fXmlFound)
{
hr = BVariantSetString(&value, scz, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
// @Type
hr = XmlGetAttributeEx(pixnNode, L"Type", &scz);
ExitOnRequiredXmlQueryFailure(hr, "Failed to get @Type.");
if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"formatted", -1))
{
if (!fHidden)
{
LogStringLine(REPORT_STANDARD, "Initializing formatted variable '%ls' to value '%ls'", sczId, value.sczValue);
}
valueType = BURN_VARIANT_TYPE_FORMATTED;
}
else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"numeric", -1))
{
if (!fHidden)
{
LogStringLine(REPORT_STANDARD, "Initializing numeric variable '%ls' to value '%ls'", sczId, value.sczValue);
}
valueType = BURN_VARIANT_TYPE_NUMERIC;
}
else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"string", -1))
{
if (!fHidden)
{
LogStringLine(REPORT_STANDARD, "Initializing string variable '%ls' to value '%ls'", sczId, value.sczValue);
}
valueType = BURN_VARIANT_TYPE_STRING;
}
else if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, scz, -1, L"version", -1))
{
if (!fHidden)
{
LogStringLine(REPORT_STANDARD, "Initializing version variable '%ls' to value '%ls'", sczId, value.sczValue);
}
valueType = BURN_VARIANT_TYPE_VERSION;
}
else
{
ExitWithRootFailure(hr, E_INVALIDARG, "Invalid value for @Type: %ls", scz);
}
}
else
{
valueType = BURN_VARIANT_TYPE_NONE;
}
if (fHidden)
{
LogStringLine(REPORT_STANDARD, "Initializing hidden variable '%ls'", sczId);
}
// change value variant to correct type
hr = BVariantChangeType(&value, valueType);
ExitOnFailure(hr, "Failed to change variant type.");
if (BURN_VARIANT_TYPE_VERSION == valueType && value.pValue->fInvalid)
{
LogId(REPORT_WARNING, MSG_VARIABLE_INVALID_VERSION, sczId);
}
// find existing variable
hr = FindVariableIndexByName(pVariables, sczId, &iVariable);
ExitOnFailure(hr, "Failed to find variable value '%ls'.", sczId);
// insert element if not found
if (S_FALSE == hr)
{
hr = InsertUserVariable(pVariables, sczId, iVariable);
ExitOnFailure(hr, "Failed to insert variable '%ls'.", sczId);
}
else if (BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariables->rgVariables[iVariable].internalType)
{
ExitWithRootFailure(hr, E_INVALIDARG, "Attempt to add built-in variable: %ls", sczId);
}
else
{
ExitWithRootFailure(hr, E_INVALIDARG, "Attempt to add variable again: %ls", sczId);
}
pVariables->rgVariables[iVariable].fHidden = fHidden;
pVariables->rgVariables[iVariable].fPersisted = fPersisted;
// update variable value
hr = BVariantSetValue(&pVariables->rgVariables[iVariable].Value, &value);
ExitOnFailure(hr, "Failed to set value of variable: %ls", sczId);
// prepare next iteration
ReleaseNullObject(pixnNode);
BVariantUninitialize(&value);
ReleaseNullStrSecure(scz);
}
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
ReleaseObject(pixnNodes);
ReleaseObject(pixnNode);
ReleaseStr(scz);
ReleaseStr(sczId);
BVariantUninitialize(&value);
return hr;
}
extern "C" void VariablesUninitialize(
__in BURN_VARIABLES* pVariables
)
{
::DeleteCriticalSection(&pVariables->csAccess);
if (pVariables->rgVariables)
{
for (DWORD i = 0; i < pVariables->cVariables; ++i)
{
BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
if (pVariable)
{
ReleaseStr(pVariable->sczName);
BVariantUninitialize(&pVariable->Value);
}
}
MemFree(pVariables->rgVariables);
}
}
extern "C" void VariablesDump(
__in BURN_VARIABLES* pVariables
)
{
HRESULT hr = S_OK;
LPWSTR sczValue = NULL;
for (DWORD i = 0; i < pVariables->cVariables; ++i)
{
BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
if (pVariable && BURN_VARIANT_TYPE_NONE != pVariable->Value.Type)
{
hr = StrAllocFormatted(&sczValue, L"%ls = [%ls]", pVariable->sczName, pVariable->sczName);
if (SUCCEEDED(hr))
{
if (pVariable->fHidden)
{
hr = VariableFormatStringObfuscated(pVariables, sczValue, &sczValue, NULL);
}
else
{
hr = VariableFormatString(pVariables, sczValue, &sczValue, NULL);
}
}
if (FAILED(hr))
{
// already logged; best-effort to dump the rest on our way out the door
continue;
}
LogId(REPORT_VERBOSE, MSG_VARIABLE_DUMP, sczValue);
ReleaseNullStrSecure(sczValue);
}
}
StrSecureZeroFreeString(sczValue);
}
extern "C" HRESULT VariableGetNumeric(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out LONGLONG* pllValue
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
{
ExitFunction1(hr = E_NOTFOUND);
}
else if (E_NOTFOUND == hr)
{
ExitFunction();
}
ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
hr = BVariantGetNumeric(&pVariable->Value, pllValue);
ExitOnFailure(hr, "Failed to get value as numeric for variable: %ls", wzVariable);
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
return hr;
}
extern "C" HRESULT VariableGetString(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out_z LPWSTR* psczValue
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
{
ExitFunction1(hr = E_NOTFOUND);
}
else if (E_NOTFOUND == hr)
{
ExitFunction();
}
ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
hr = BVariantGetString(&pVariable->Value, psczValue);
ExitOnFailure(hr, "Failed to get value as string for variable: %ls", wzVariable);
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
return hr;
}
extern "C" HRESULT VariableGetVersion(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in VERUTIL_VERSION** ppValue
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
{
ExitFunction1(hr = E_NOTFOUND);
}
else if (E_NOTFOUND == hr)
{
ExitFunction();
}
ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
hr = BVariantGetVersionHidden(&pVariable->Value, pVariable->fHidden, ppValue);
ExitOnFailure(hr, "Failed to get value as version for variable: %ls", wzVariable);
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
return hr;
}
extern "C" HRESULT VariableGetVariant(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (E_NOTFOUND == hr)
{
ExitFunction();
}
ExitOnFailure(hr, "Failed to get value of variable: %ls", wzVariable);
hr = BVariantCopy(&pVariable->Value, pValue);
ExitOnFailure(hr, "Failed to copy value of variable: %ls", wzVariable);
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
return hr;
}
extern "C" HRESULT VariableGetFormatted(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out_z LPWSTR* psczValue,
__out BOOL* pfContainsHiddenVariable
)
{
HRESULT hr = S_OK;
if (pfContainsHiddenVariable)
{
*pfContainsHiddenVariable = FALSE;
}
hr = GetFormatted(pVariables, wzVariable, psczValue, pfContainsHiddenVariable);
return hr;
}
extern "C" HRESULT VariableSetNumeric(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in LONGLONG llValue,
__in BOOL fOverwriteBuiltIn
)
{
BURN_VARIANT variant = { };
variant.llValue = llValue;
variant.Type = BURN_VARIANT_TYPE_NUMERIC;
return SetVariableValue(pVariables, wzVariable, &variant, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
}
extern "C" HRESULT VariableSetString(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in_z_opt LPCWSTR wzValue,
__in BOOL fOverwriteBuiltIn,
__in BOOL fFormatted
)
{
BURN_VARIANT variant = { };
variant.sczValue = (LPWSTR)wzValue;
variant.Type = fFormatted ? BURN_VARIANT_TYPE_FORMATTED : BURN_VARIANT_TYPE_STRING;
return SetVariableValue(pVariables, wzVariable, &variant, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
}
extern "C" HRESULT VariableSetVersion(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in VERUTIL_VERSION* pValue,
__in BOOL fOverwriteBuiltIn
)
{
BURN_VARIANT variant = { };
variant.pValue = pValue;
variant.Type = BURN_VARIANT_TYPE_VERSION;
return SetVariableValue(pVariables, wzVariable, &variant, fOverwriteBuiltIn ? SET_VARIABLE_OVERRIDE_BUILTIN : SET_VARIABLE_NOT_BUILTIN, TRUE);
}
extern "C" HRESULT VariableSetVariant(
__in BURN_VARIABLES * pVariables,
__in_z LPCWSTR wzVariable,
__in BURN_VARIANT * pVariant
)
{
return SetVariableValue(pVariables, wzVariable, pVariant, SET_VARIABLE_NOT_BUILTIN, TRUE);
}
extern "C" HRESULT VariableFormatString(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzIn,
__out_z_opt LPWSTR* psczOut,
__out_opt SIZE_T* pcchOut
)
{
return FormatString(pVariables, wzIn, psczOut, pcchOut, FALSE, NULL);
}
extern "C" HRESULT VariableFormatStringObfuscated(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzIn,
__out_z_opt LPWSTR* psczOut,
__out_opt SIZE_T* pcchOut
)
{
return FormatString(pVariables, wzIn, psczOut, pcchOut, TRUE, NULL);
}
extern "C" HRESULT VariableEscapeString(
__in_z LPCWSTR wzIn,
__out_z LPWSTR* psczOut
)
{
HRESULT hr = S_OK;
LPCWSTR wzRead = NULL;
LPWSTR pwzEscaped = NULL;
LPWSTR pwz = NULL;
SIZE_T i = 0;
// allocate buffer for escaped string
hr = StrAlloc(&pwzEscaped, lstrlenW(wzIn) + 1);
ExitOnFailure(hr, "Failed to allocate buffer for escaped string.");
// read through string and move characters, inserting escapes as needed
wzRead = wzIn;
for (;;)
{
// find next character needing escaping
i = wcscspn(wzRead, L"[]{}");
// copy skipped characters
if (0 < i)
{
hr = StrAllocConcat(&pwzEscaped, wzRead, i);
ExitOnFailure(hr, "Failed to append characters.");
}
if (L'\0' == wzRead[i])
{
break; // end reached
}
// escape character
hr = StrAllocFormatted(&pwz, L"[\\%c]", wzRead[i]);
ExitOnFailure(hr, "Failed to format escape sequence.");
hr = StrAllocConcat(&pwzEscaped, pwz, 0);
ExitOnFailure(hr, "Failed to append escape sequence.");
// update read pointer
wzRead += i + 1;
}
// return value
hr = StrAllocString(psczOut, pwzEscaped, 0);
ExitOnFailure(hr, "Failed to copy string.");
LExit:
ReleaseStr(pwzEscaped);
ReleaseStr(pwz);
return hr;
}
extern "C" HRESULT VariableSerialize(
__in BURN_VARIABLES* pVariables,
__in BOOL fPersisting,
__inout BYTE** ppbBuffer,
__inout SIZE_T* piBuffer
)
{
HRESULT hr = S_OK;
BOOL fIncluded = FALSE;
LONGLONG ll = 0;
LPWSTR scz = NULL;
::EnterCriticalSection(&pVariables->csAccess);
// Write variable count.
hr = BuffWriteNumber(ppbBuffer, piBuffer, pVariables->cVariables);
ExitOnFailure(hr, "Failed to write variable count.");
// Write variables.
for (DWORD i = 0; i < pVariables->cVariables; ++i)
{
BURN_VARIABLE* pVariable = &pVariables->rgVariables[i];
// If we aren't persisting, include only variables that aren't rejected by the elevated process.
// If we are persisting, include only variables that should be persisted.
fIncluded = (!fPersisting && BURN_VARIABLE_INTERNAL_TYPE_BUILTIN != pVariable->internalType) ||
(fPersisting && pVariable->fPersisted);
// Write included flag.
hr = BuffWriteNumber(ppbBuffer, piBuffer, (DWORD)fIncluded);
ExitOnFailure(hr, "Failed to write included flag.");
if (!fIncluded)
{
continue;
}
// Write variable name.
hr = BuffWriteString(ppbBuffer, piBuffer, pVariable->sczName);
ExitOnFailure(hr, "Failed to write variable name.");
// Write variable value type.
hr = BuffWriteNumber(ppbBuffer, piBuffer, (DWORD)pVariable->Value.Type);
ExitOnFailure(hr, "Failed to write variable value type.");
// Write variable value.
switch (pVariable->Value.Type)
{
case BURN_VARIANT_TYPE_NONE:
break;
case BURN_VARIANT_TYPE_NUMERIC:
hr = BVariantGetNumeric(&pVariable->Value, &ll);
ExitOnFailure(hr, "Failed to get numeric.");
hr = BuffWriteNumber64(ppbBuffer, piBuffer, static_cast<DWORD64>(ll));
ExitOnFailure(hr, "Failed to write variable value as number.");
SecureZeroMemory(&ll, sizeof(ll));
break;
case BURN_VARIANT_TYPE_VERSION: __fallthrough;
case BURN_VARIANT_TYPE_FORMATTED: __fallthrough;
case BURN_VARIANT_TYPE_STRING:
hr = BVariantGetString(&pVariable->Value, &scz);
ExitOnFailure(hr, "Failed to get string.");
hr = BuffWriteString(ppbBuffer, piBuffer, scz);
ExitOnFailure(hr, "Failed to write variable value as string.");
ReleaseNullStrSecure(scz);
break;
default:
hr = E_INVALIDARG;
ExitOnFailure(hr, "Unsupported variable type.");
}
}
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
SecureZeroMemory(&ll, sizeof(ll));
StrSecureZeroFreeString(scz);
return hr;
}
extern "C" HRESULT VariableDeserialize(
__in BURN_VARIABLES* pVariables,
__in BOOL fWasPersisted,
__in_bcount(cbBuffer) BYTE* pbBuffer,
__in SIZE_T cbBuffer,
__inout SIZE_T* piBuffer
)
{
HRESULT hr = S_OK;
DWORD cVariables = 0;
LPWSTR sczName = NULL;
BOOL fIncluded = FALSE;
BURN_VARIANT value = { };
LPWSTR scz = NULL;
DWORD64 qw = 0;
VERUTIL_VERSION* pVersion = NULL;
::EnterCriticalSection(&pVariables->csAccess);
// Read variable count.
hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, &cVariables);
ExitOnFailure(hr, "Failed to read variable count.");
// Read variables.
for (DWORD i = 0; i < cVariables; ++i)
{
// Read variable included flag.
hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, (DWORD*)&fIncluded);
ExitOnFailure(hr, "Failed to read variable included flag.");
if (!fIncluded)
{
continue; // if variable is not included, skip.
}
// Read variable name.
hr = BuffReadString(pbBuffer, cbBuffer, piBuffer, &sczName);
ExitOnFailure(hr, "Failed to read variable name.");
// Read variable value type.
hr = BuffReadNumber(pbBuffer, cbBuffer, piBuffer, (DWORD*)&value.Type);
ExitOnFailure(hr, "Failed to read variable value type.");
// Read variable value.
switch (value.Type)
{
case BURN_VARIANT_TYPE_NONE:
break;
case BURN_VARIANT_TYPE_NUMERIC:
hr = BuffReadNumber64(pbBuffer, cbBuffer, piBuffer, &qw);
ExitOnFailure(hr, "Failed to read variable value as number.");
hr = BVariantSetNumeric(&value, static_cast<LONGLONG>(qw));
ExitOnFailure(hr, "Failed to set variable value.");
SecureZeroMemory(&qw, sizeof(qw));
break;
case BURN_VARIANT_TYPE_VERSION:
hr = BuffReadString(pbBuffer, cbBuffer, piBuffer, &scz);
ExitOnFailure(hr, "Failed to read variable value as string.");
hr = VerParseVersion(scz, 0, FALSE, &pVersion);
ExitOnFailure(hr, "Failed to parse variable value as version.");
hr = BVariantSetVersion(&value, pVersion);
ExitOnFailure(hr, "Failed to set variable value.");
SecureZeroMemory(&qw, sizeof(qw));
break;
case BURN_VARIANT_TYPE_FORMATTED: __fallthrough;
case BURN_VARIANT_TYPE_STRING:
hr = BuffReadString(pbBuffer, cbBuffer, piBuffer, &scz);
ExitOnFailure(hr, "Failed to read variable value as string.");
hr = BVariantSetString(&value, scz, NULL, BURN_VARIANT_TYPE_FORMATTED == value.Type);
ExitOnFailure(hr, "Failed to set variable value.");
ReleaseNullStrSecure(scz);
break;
default:
hr = E_INVALIDARG;
ExitOnFailure(hr, "Unsupported variable type.");
}
// Set variable.
hr = SetVariableValue(pVariables, sczName, &value, fWasPersisted ? SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS : SET_VARIABLE_ANY, FALSE);
ExitOnFailure(hr, "Failed to set variable.");
// Clean up.
BVariantUninitialize(&value);
}
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
ReleaseVerutilVersion(pVersion);
ReleaseStr(sczName);
BVariantUninitialize(&value);
SecureZeroMemory(&qw, sizeof(qw));
StrSecureZeroFreeString(scz);
return hr;
}
extern "C" HRESULT VariableStrAlloc(
__in BOOL fZeroOnRealloc,
__deref_out_ecount_part(cch, 0) LPWSTR* ppwz,
__in DWORD_PTR cch
)
{
HRESULT hr = S_OK;
if (fZeroOnRealloc)
{
hr = StrAllocSecure(ppwz, cch);
}
else
{
hr = StrAlloc(ppwz, cch);
}
return hr;
}
extern "C" HRESULT VariableStrAllocString(
__in BOOL fZeroOnRealloc,
__deref_out_ecount_z(cchSource + 1) LPWSTR* ppwz,
__in_z LPCWSTR wzSource,
__in DWORD_PTR cchSource
)
{
HRESULT hr = S_OK;
if (fZeroOnRealloc)
{
hr = StrAllocStringSecure(ppwz, wzSource, cchSource);
}
else
{
hr = StrAllocString(ppwz, wzSource, cchSource);
}
return hr;
}
extern "C" HRESULT VariableStrAllocConcat(
__in BOOL fZeroOnRealloc,
__deref_out_z LPWSTR* ppwz,
__in_z LPCWSTR wzSource,
__in DWORD_PTR cchSource
)
{
HRESULT hr = S_OK;
if (fZeroOnRealloc)
{
hr = StrAllocConcatSecure(ppwz, wzSource, cchSource);
}
else
{
hr = StrAllocConcat(ppwz, wzSource, cchSource);
}
return hr;
}
extern "C" HRESULT __cdecl VariableStrAllocFormatted(
__in BOOL fZeroOnRealloc,
__deref_out_z LPWSTR* ppwz,
__in __format_string LPCWSTR wzFormat,
...
)
{
HRESULT hr = S_OK;
va_list args;
va_start(args, wzFormat);
if (fZeroOnRealloc)
{
hr = StrAllocFormattedArgsSecure(ppwz, wzFormat, args);
}
else
{
hr = StrAllocFormattedArgs(ppwz, wzFormat, args);
}
va_end(args);
return hr;
}
extern "C" HRESULT VariableIsHidden(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out BOOL* pfHidden
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (E_NOTFOUND == hr)
{
// A missing variable does not need its data hidden.
*pfHidden = FALSE;
ExitFunction1(hr = S_OK);
}
ExitOnFailure(hr, "Failed to get visibility of variable: %ls", wzVariable);
*pfHidden = pVariable->fHidden;
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
return hr;
}
extern "C" BOOL VariableIsHiddenCommandLine(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable
)
{
BURN_VARIABLE* pVariable = NULL;
BOOL fHidden = FALSE;
::EnterCriticalSection(&pVariables->csAccess);
for (DWORD i = 0; i < pVariables->cVariables; ++i)
{
pVariable = pVariables->rgVariables + i;
if (pVariable->fHidden && CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, NORM_IGNORECASE, pVariable->sczName, -1, wzVariable, -1))
{
fHidden = TRUE;
break;
}
}
::LeaveCriticalSection(&pVariables->csAccess);
return fHidden;
}
// internal function definitions
static HRESULT FormatString(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzIn,
__out_z_opt LPWSTR* psczOut,
__out_opt SIZE_T* pcchOut,
__in BOOL fObfuscateHiddenVariables,
__out BOOL* pfContainsHiddenVariable
)
{
HRESULT hr = S_OK;
DWORD er = ERROR_SUCCESS;
LPWSTR sczUnformatted = NULL;
LPWSTR sczFormat = NULL;
LPCWSTR wzRead = NULL;
LPCWSTR wzOpen = NULL;
LPCWSTR wzClose = NULL;
LPWSTR scz = NULL;
LPWSTR* rgVariables = NULL;
DWORD cVariables = 0;
DWORD cch = 0;
size_t cchIn = 0;
BOOL fHidden = FALSE;
MSIHANDLE hRecord = NULL;
::EnterCriticalSection(&pVariables->csAccess);
// allocate buffer for format string
hr = ::StringCchLengthW(wzIn, STRSAFE_MAX_LENGTH, &cchIn);
ExitOnFailure(hr, "Failed to length of format string.");
hr = StrAlloc(&sczFormat, cchIn + 1);
ExitOnFailure(hr, "Failed to allocate buffer for format string.");
// read out variables from the unformatted string and build a format string
wzRead = wzIn;
for (;;)
{
// scan for opening '['
wzOpen = wcschr(wzRead, L'[');
if (!wzOpen)
{
// end reached, append the remainder of the string and end loop
hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, 0);
ExitOnFailure(hr, "Failed to append string.");
break;
}
// scan for closing ']'
wzClose = wcschr(wzOpen + 1, L']');
if (!wzClose)
{
// end reached, treat unterminated expander as literal
hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, 0);
ExitOnFailure(hr, "Failed to append string.");
break;
}
cch = (DWORD)(wzClose - wzOpen - 1);
if (0 == cch)
{
// blank, copy all text including the terminator
hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, (DWORD_PTR)(wzClose - wzRead) + 1);
ExitOnFailure(hr, "Failed to append string.");
}
else
{
// append text preceding expander
if (wzOpen > wzRead)
{
hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, wzRead, (DWORD_PTR)(wzOpen - wzRead));
ExitOnFailure(hr, "Failed to append string.");
}
// get variable name
hr = VariableStrAllocString(!fObfuscateHiddenVariables, &scz, wzOpen + 1, cch);
ExitOnFailure(hr, "Failed to get variable name.");
// allocate space in variable array
if (rgVariables)
{
LPVOID pv = MemReAlloc(rgVariables, sizeof(LPWSTR) * (cVariables + 1), TRUE);
ExitOnNull(pv, hr, E_OUTOFMEMORY, "Failed to reallocate variable array.");
rgVariables = (LPWSTR*)pv;
}
else
{
rgVariables = (LPWSTR*)MemAlloc(sizeof(LPWSTR) * (cVariables + 1), TRUE);
ExitOnNull(rgVariables, hr, E_OUTOFMEMORY, "Failed to allocate variable array.");
}
// set variable value
if (2 <= cch && L'\\' == wzOpen[1])
{
// escape sequence, copy character
hr = VariableStrAllocString(!fObfuscateHiddenVariables, &rgVariables[cVariables], &wzOpen[2], 1);
}
else
{
hr = VariableIsHidden(pVariables, scz, &fHidden);
ExitOnFailure(hr, "Failed to determine variable visibility: '%ls'.", scz);
if (pfContainsHiddenVariable)
{
*pfContainsHiddenVariable |= fHidden;
}
if (fObfuscateHiddenVariables && fHidden)
{
hr = StrAllocString(&rgVariables[cVariables], L"*****", 0);
}
else
{
// get formatted variable value
hr = GetFormatted(pVariables, scz, &rgVariables[cVariables], pfContainsHiddenVariable);
if (E_NOTFOUND == hr) // variable not found
{
hr = StrAllocStringSecure(&rgVariables[cVariables], L"", 0);
}
}
}
ExitOnFailure(hr, "Failed to set variable value.");
++cVariables;
// append placeholder to format string
hr = VariableStrAllocFormatted(!fObfuscateHiddenVariables, &scz, L"[%d]", cVariables);
ExitOnFailure(hr, "Failed to format placeholder string.");
hr = VariableStrAllocConcat(!fObfuscateHiddenVariables, &sczFormat, scz, 0);
ExitOnFailure(hr, "Failed to append placeholder.");
}
// update read pointer
wzRead = wzClose + 1;
}
// create record
hRecord = ::MsiCreateRecord(cVariables);
ExitOnNull(hRecord, hr, E_OUTOFMEMORY, "Failed to allocate record.");
// set format string
er = ::MsiRecordSetStringW(hRecord, 0, sczFormat);
ExitOnWin32Error(er, hr, "Failed to set record format string.");
// copy record fields
for (DWORD i = 0; i < cVariables; ++i)
{
if (*rgVariables[i]) // not setting if blank
{
er = ::MsiRecordSetStringW(hRecord, i + 1, rgVariables[i]);
ExitOnWin32Error(er, hr, "Failed to set record string.");
}
}
// get formatted character count
cch = 0;
#pragma prefast(push)
#pragma prefast(disable:6298)
er = ::MsiFormatRecordW(NULL, hRecord, L"", &cch);
#pragma prefast(pop)
if (ERROR_MORE_DATA != er)
{
ExitOnWin32Error(er, hr, "Failed to get formatted length.");
}
// return formatted string
if (psczOut)
{
hr = VariableStrAlloc(!fObfuscateHiddenVariables, &scz, ++cch);
ExitOnFailure(hr, "Failed to allocate string.");
er = ::MsiFormatRecordW(NULL, hRecord, scz, &cch);
ExitOnWin32Error(er, hr, "Failed to format record.");
hr = VariableStrAllocString(!fObfuscateHiddenVariables, psczOut, scz, 0);
ExitOnFailure(hr, "Failed to copy string.");
}
// return character count
if (pcchOut)
{
*pcchOut = cch;
}
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
if (rgVariables)
{
for (DWORD i = 0; i < cVariables; ++i)
{
if (fObfuscateHiddenVariables)
{
ReleaseStr(rgVariables[i]);
}
else
{
StrSecureZeroFreeString(rgVariables[i]);
}
}
MemFree(rgVariables);
}
if (hRecord)
{
::MsiCloseHandle(hRecord);
}
if (fObfuscateHiddenVariables)
{
ReleaseStr(sczUnformatted);
ReleaseStr(sczFormat);
ReleaseStr(scz);
}
else
{
StrSecureZeroFreeString(sczUnformatted);
StrSecureZeroFreeString(sczFormat);
StrSecureZeroFreeString(scz);
}
return hr;
}
static HRESULT GetFormatted(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out_z LPWSTR* psczValue,
__out BOOL* pfContainsHiddenVariable
)
{
HRESULT hr = S_OK;
BURN_VARIABLE* pVariable = NULL;
LPWSTR scz = NULL;
::EnterCriticalSection(&pVariables->csAccess);
hr = GetVariable(pVariables, wzVariable, &pVariable);
if (SUCCEEDED(hr) && BURN_VARIANT_TYPE_NONE == pVariable->Value.Type)
{
ExitFunction1(hr = E_NOTFOUND);
}
else if (E_NOTFOUND == hr)
{
ExitFunction();
}
ExitOnFailure(hr, "Failed to get variable: %ls", wzVariable);
if (pfContainsHiddenVariable)
{
*pfContainsHiddenVariable |= pVariable->fHidden;
}
if (BURN_VARIANT_TYPE_FORMATTED == pVariable->Value.Type)
{
hr = BVariantGetString(&pVariable->Value, &scz);
ExitOnFailure(hr, "Failed to get unformatted string.");
hr = FormatString(pVariables, scz, psczValue, NULL, FALSE, pfContainsHiddenVariable);
ExitOnFailure(hr, "Failed to format value '%ls' of variable: %ls", pVariable->fHidden ? L"*****" : pVariable->Value.sczValue, wzVariable);
}
else
{
hr = BVariantGetString(&pVariable->Value, psczValue);
ExitOnFailure(hr, "Failed to get value as string for variable: %ls", wzVariable);
}
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
StrSecureZeroFreeString(scz);
return hr;
}
static HRESULT AddBuiltInVariable(
__in BURN_VARIABLES* pVariables,
__in LPCWSTR wzVariable,
__in PFN_INITIALIZEVARIABLE pfnInitialize,
__in DWORD_PTR dwpInitializeData,
__in BOOL fPersist,
__in BOOL fOverridable
)
{
HRESULT hr = S_OK;
DWORD iVariable = 0;
BURN_VARIABLE* pVariable = NULL;
hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
ExitOnFailure(hr, "Failed to find variable value.");
// insert element if not found
if (S_FALSE == hr)
{
hr = InsertVariable(pVariables, wzVariable, iVariable);
ExitOnFailure(hr, "Failed to insert variable.");
}
else
{
ExitWithRootFailure(hr, E_INVALIDSTATE, "Attempted to add built-in variable again: %ls", wzVariable);
}
// set variable details
pVariable = &pVariables->rgVariables[iVariable];
pVariable->fPersisted = fPersist;
pVariable->internalType = fOverridable ? BURN_VARIABLE_INTERNAL_TYPE_OVERRIDABLE_BUILTIN : BURN_VARIABLE_INTERNAL_TYPE_BUILTIN;
pVariable->pfnInitialize = pfnInitialize;
pVariable->dwpInitializeData = dwpInitializeData;
LExit:
return hr;
}
static HRESULT AddWellKnownVariable(
__in BURN_VARIABLES* pVariables,
__in LPCWSTR wzVariable,
__in BOOL fPersisted
)
{
HRESULT hr = S_OK;
DWORD iVariable = 0;
BURN_VARIABLE* pVariable = NULL;
hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
ExitOnFailure(hr, "Failed to find variable value.");
// insert element if not found
if (S_FALSE == hr)
{
hr = InsertVariable(pVariables, wzVariable, iVariable);
ExitOnFailure(hr, "Failed to insert variable.");
}
else if (BURN_VARIABLE_INTERNAL_TYPE_NORMAL != pVariables->rgVariables[iVariable].internalType)
{
ExitWithRootFailure(hr, E_INVALIDSTATE, "Attempted to add built-in variable as a well-known variable: %ls", wzVariable);
}
else
{
ExitWithRootFailure(hr, E_INVALIDSTATE, "Attempted to add well-known variable again: %ls", wzVariable);
}
// set variable details
pVariable = &pVariables->rgVariables[iVariable];
pVariable->fPersisted = fPersisted;
pVariable->internalType = BURN_VARIABLE_INTERNAL_TYPE_NORMAL;
LExit:
return hr;
}
static HRESULT GetVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out BURN_VARIABLE** ppVariable
)
{
HRESULT hr = S_OK;
DWORD iVariable = 0;
BURN_VARIABLE* pVariable = NULL;
hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
ExitOnFailure(hr, "Failed to find variable value '%ls'.", wzVariable);
if (S_FALSE == hr)
{
ExitFunction1(hr = E_NOTFOUND);
}
pVariable = &pVariables->rgVariables[iVariable];
// initialize built-in variable
if (BURN_VARIANT_TYPE_NONE == pVariable->Value.Type && BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariable->internalType)
{
hr = pVariable->pfnInitialize(pVariable->dwpInitializeData, &pVariable->Value);
ExitOnFailure(hr, "Failed to initialize built-in variable value '%ls'.", wzVariable);
}
*ppVariable = pVariable;
LExit:
return hr;
}
static HRESULT FindVariableIndexByName(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__out DWORD* piVariable
)
{
HRESULT hr = S_OK;
DWORD iRangeFirst = 0;
DWORD cRangeLength = pVariables->cVariables;
while (cRangeLength)
{
// get variable in middle of range
DWORD iPosition = cRangeLength / 2;
BURN_VARIABLE* pVariable = &pVariables->rgVariables[iRangeFirst + iPosition];
switch (::CompareStringW(LOCALE_INVARIANT, SORT_STRINGSORT, wzVariable, -1, pVariable->sczName, -1))
{
case CSTR_LESS_THAN:
// restrict range to elements before the current
cRangeLength = iPosition;
break;
case CSTR_EQUAL:
// variable found
*piVariable = iRangeFirst + iPosition;
ExitFunction1(hr = S_OK);
case CSTR_GREATER_THAN:
// restrict range to elements after the current
iRangeFirst += iPosition + 1;
cRangeLength -= iPosition + 1;
break;
default:
ExitWithLastError(hr, "Failed to compare strings.");
}
}
*piVariable = iRangeFirst;
hr = S_FALSE; // variable not found
LExit:
return hr;
}
static HRESULT InsertUserVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in DWORD iPosition
)
{
HRESULT hr = S_OK;
if (CSTR_EQUAL == ::CompareStringW(LOCALE_INVARIANT, 0, wzVariable, 3, L"Wix", 3))
{
ExitWithRootFailure(hr, E_INVALIDARG, "Attempted to insert variable with reserved prefix: %ls", wzVariable);
}
hr = InsertVariable(pVariables, wzVariable, iPosition);
LExit:
return hr;
}
static HRESULT InsertVariable(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in DWORD iPosition
)
{
HRESULT hr = S_OK;
size_t cbAllocSize = 0;
// ensure there is room in the variable array
if (pVariables->cVariables == pVariables->dwMaxVariables)
{
hr = ::DWordAdd(pVariables->dwMaxVariables, GROW_VARIABLE_ARRAY, &(pVariables->dwMaxVariables));
ExitOnRootFailure(hr, "Overflow while growing variable array size");
if (pVariables->rgVariables)
{
hr = ::SizeTMult(sizeof(BURN_VARIABLE), pVariables->dwMaxVariables, &cbAllocSize);
ExitOnRootFailure(hr, "Overflow while calculating size of variable array buffer");
LPVOID pv = MemReAlloc(pVariables->rgVariables, cbAllocSize, FALSE);
ExitOnNull(pv, hr, E_OUTOFMEMORY, "Failed to allocate room for more variables.");
// Prefast claims it's possible to hit this. Putting the check in just in case.
if (pVariables->dwMaxVariables < pVariables->cVariables)
{
hr = INTSAFE_E_ARITHMETIC_OVERFLOW;
ExitOnRootFailure(hr, "Overflow while dealing with variable array buffer allocation");
}
pVariables->rgVariables = (BURN_VARIABLE*)pv;
memset(&pVariables->rgVariables[pVariables->cVariables], 0, sizeof(BURN_VARIABLE) * (pVariables->dwMaxVariables - pVariables->cVariables));
}
else
{
pVariables->rgVariables = (BURN_VARIABLE*)MemAlloc(sizeof(BURN_VARIABLE) * pVariables->dwMaxVariables, TRUE);
ExitOnNull(pVariables->rgVariables, hr, E_OUTOFMEMORY, "Failed to allocate room for variables.");
}
}
// move variables
if (0 < pVariables->cVariables - iPosition)
{
memmove(&pVariables->rgVariables[iPosition + 1], &pVariables->rgVariables[iPosition], sizeof(BURN_VARIABLE) * (pVariables->cVariables - iPosition));
memset(&pVariables->rgVariables[iPosition], 0, sizeof(BURN_VARIABLE));
}
++pVariables->cVariables;
// allocate name
hr = StrAllocString(&pVariables->rgVariables[iPosition].sczName, wzVariable, 0);
ExitOnFailure(hr, "Failed to copy variable name.");
LExit:
return hr;
}
static HRESULT SetVariableValue(
__in BURN_VARIABLES* pVariables,
__in_z LPCWSTR wzVariable,
__in BURN_VARIANT* pVariant,
__in SET_VARIABLE setBuiltin,
__in BOOL fLog
)
{
HRESULT hr = S_OK;
DWORD iVariable = 0;
::EnterCriticalSection(&pVariables->csAccess);
hr = FindVariableIndexByName(pVariables, wzVariable, &iVariable);
ExitOnFailure(hr, "Failed to find variable value '%ls'.", wzVariable);
// Insert element if not found.
if (S_FALSE == hr)
{
// Not possible from external callers so just assert.
AssertSz(SET_VARIABLE_OVERRIDE_BUILTIN != setBuiltin, "Intent to set missing built-in variable.");
hr = InsertVariable(pVariables, wzVariable, iVariable);
ExitOnFailure(hr, "Failed to insert variable '%ls'.", wzVariable);
}
else if (BURN_VARIABLE_INTERNAL_TYPE_NORMAL < pVariables->rgVariables[iVariable].internalType) // built-in variables must be overridden.
{
if (SET_VARIABLE_OVERRIDE_BUILTIN == setBuiltin ||
(SET_VARIABLE_OVERRIDE_PERSISTED_BUILTINS == setBuiltin && pVariables->rgVariables[iVariable].fPersisted) ||
SET_VARIABLE_ANY == setBuiltin && BURN_VARIABLE_INTERNAL_TYPE_BUILTIN != pVariables->rgVariables[iVariable].internalType)
{
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
ExitOnRootFailure(hr, "Attempt to set built-in variable value: %ls", wzVariable);
}
}
else // must *not* be a built-in variable so caller should not have tried to override it as a built-in.
{
// Not possible from external callers so just assert.
AssertSz(SET_VARIABLE_OVERRIDE_BUILTIN != setBuiltin, "Intent to overwrite non-built-in variable.");
}
// Log value when not overwriting a built-in variable.
if (fLog && BURN_VARIABLE_INTERNAL_TYPE_NORMAL == pVariables->rgVariables[iVariable].internalType)
{
if (pVariables->rgVariables[iVariable].fHidden)
{
LogStringLine(REPORT_STANDARD, "Setting hidden variable '%ls'", wzVariable);
}
else
{
switch (pVariant->Type)
{
case BURN_VARIANT_TYPE_NONE:
if (BURN_VARIANT_TYPE_NONE != pVariables->rgVariables[iVariable].Value.Type)
{
LogStringLine(REPORT_STANDARD, "Unsetting variable '%ls'", wzVariable);
}
break;
case BURN_VARIANT_TYPE_NUMERIC:
LogStringLine(REPORT_STANDARD, "Setting numeric variable '%ls' to value %lld", wzVariable, pVariant->llValue);
break;
case BURN_VARIANT_TYPE_FORMATTED: __fallthrough;
case BURN_VARIANT_TYPE_STRING:
if (!pVariant->sczValue)
{
LogStringLine(REPORT_STANDARD, "Unsetting variable '%ls'", wzVariable);
}
else
{
LogStringLine(REPORT_STANDARD, "Setting %ls variable '%ls' to value '%ls'", BURN_VARIANT_TYPE_FORMATTED == pVariant->Type ? L"formatted" : L"string", wzVariable, pVariant->sczValue);
}
break;
case BURN_VARIANT_TYPE_VERSION:
if (!pVariant->pValue)
{
LogStringLine(REPORT_STANDARD, "Unsetting variable '%ls'", wzVariable);
}
else
{
LogStringLine(REPORT_STANDARD, "Setting version variable '%ls' to value '%ls'", wzVariable, pVariant->pValue->sczVersion);
}
break;
default:
AssertSz(FALSE, "Unknown variant type.");
break;
}
}
if (BURN_VARIANT_TYPE_VERSION == pVariant->Type && pVariant->pValue && pVariant->pValue->fInvalid)
{
LogId(REPORT_WARNING, MSG_VARIABLE_INVALID_VERSION, wzVariable);
}
}
// Update variable value.
hr = BVariantSetValue(&pVariables->rgVariables[iVariable].Value, pVariant);
ExitOnFailure(hr, "Failed to set value of variable: %ls", wzVariable);
LExit:
::LeaveCriticalSection(&pVariables->csAccess);
if (FAILED(hr) && fLog)
{
LogStringLine(REPORT_STANDARD, "Setting variable failed: ID '%ls', HRESULT 0x%x", wzVariable, hr);
}
return hr;
}
static HRESULT InitializeVariableVersionNT(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
RTL_OSVERSIONINFOEXW ovix = { };
BURN_VARIANT value = { };
VERUTIL_VERSION* pVersion = NULL;
hr = OsRtlGetVersion(&ovix);
ExitOnFailure(hr, "Failed to get OS info.");
switch ((OS_INFO_VARIABLE)dwpData)
{
case OS_INFO_VARIABLE_ServicePackLevel:
if (0 != ovix.wServicePackMajor)
{
value.llValue = static_cast<LONGLONG>(ovix.wServicePackMajor);
value.Type = BURN_VARIANT_TYPE_NUMERIC;
}
break;
case OS_INFO_VARIABLE_VersionNT:
hr = VerVersionFromQword(MAKEQWORDVERSION(ovix.dwMajorVersion, ovix.dwMinorVersion, 0, 0), &pVersion);
ExitOnFailure(hr, "Failed to create VersionNT from QWORD.");
value.pValue = pVersion;
value.Type = BURN_VARIANT_TYPE_VERSION;
break;
case OS_INFO_VARIABLE_VersionNT64:
{
#if !defined(_WIN64)
BOOL fIsWow64 = FALSE;
ProcWow64(::GetCurrentProcess(), &fIsWow64);
if (fIsWow64)
#endif
{
hr = VerVersionFromQword(MAKEQWORDVERSION(ovix.dwMajorVersion, ovix.dwMinorVersion, 0, 0), &pVersion);
ExitOnFailure(hr, "Failed to create VersionNT64 from QWORD.");
value.pValue = pVersion;
value.Type = BURN_VARIANT_TYPE_VERSION;
}
}
break;
case OS_INFO_VARIABLE_WindowsBuildNumber:
value.llValue = static_cast<LONGLONG>(ovix.dwBuildNumber);
value.Type = BURN_VARIANT_TYPE_NUMERIC;
default:
AssertSz(FALSE, "Unknown OS info type.");
break;
}
hr = BVariantCopy(&value, pValue);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseVerutilVersion(pVersion);
return hr;
}
static HRESULT InitializeVariableOsInfo(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
RTL_OSVERSIONINFOEXW ovix = { };
BURN_VARIANT value = { };
hr = OsRtlGetVersion(&ovix);
ExitOnFailure(hr, "Failed to get OS info.");
switch ((OS_INFO_VARIABLE)dwpData)
{
case OS_INFO_VARIABLE_NTProductType:
value.llValue = ovix.wProductType;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteBackOffice:
value.llValue = VER_SUITE_BACKOFFICE & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteDataCenter:
value.llValue = VER_SUITE_DATACENTER & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteEnterprise:
value.llValue = VER_SUITE_ENTERPRISE & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuitePersonal:
value.llValue = VER_SUITE_PERSONAL & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteSmallBusiness:
value.llValue = VER_SUITE_SMALLBUSINESS & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteSmallBusinessRestricted:
value.llValue = VER_SUITE_SMALLBUSINESS_RESTRICTED & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_NTSuiteWebServer:
value.llValue = VER_SUITE_BLADE & ovix.wSuiteMask ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
case OS_INFO_VARIABLE_CompatibilityMode:
{
DWORDLONG dwlConditionMask = 0;
VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_EQUAL);
VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_EQUAL);
VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMAJOR, VER_EQUAL);
VER_SET_CONDITION(dwlConditionMask, VER_SERVICEPACKMINOR, VER_EQUAL);
value.llValue = ::VerifyVersionInfoW(&ovix, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR, dwlConditionMask);
value.Type = BURN_VARIANT_TYPE_NUMERIC;
}
break;
case OS_INFO_VARIABLE_TerminalServer:
value.llValue = (VER_SUITE_TERMINAL == (ovix.wSuiteMask & VER_SUITE_TERMINAL)) && (VER_SUITE_SINGLEUSERTS != (ovix.wSuiteMask & VER_SUITE_SINGLEUSERTS)) ? 1 : 0;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
default:
AssertSz(FALSE, "Unknown OS info type.");
break;
}
hr = BVariantCopy(&value, pValue);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableSystemInfo(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
SYSTEM_INFO si = { };
BURN_VARIANT value = { };
::GetNativeSystemInfo(&si);
switch ((OS_INFO_VARIABLE)dwpData)
{
case OS_INFO_VARIABLE_ProcessorArchitecture:
value.llValue = si.wProcessorArchitecture;
value.Type = BURN_VARIANT_TYPE_NUMERIC;
break;
default:
AssertSz(FALSE, "Unknown OS info type.");
break;
}
hr = BVariantCopy(&value, pValue);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableNativeMachine(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
USHORT usNativeMachine = IMAGE_FILE_MACHINE_UNKNOWN;
hr = ProcNativeMachine(::GetCurrentProcess(), &usNativeMachine);
ExitOnFailure(hr, "Failed to get native machine value.");
if (S_FALSE != hr)
{
hr = BVariantSetNumeric(pValue, usNativeMachine);
ExitOnFailure(hr, "Failed to set variant value.");
}
LExit:
return hr;
}
static HRESULT InitializeVariableComputerName(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
WCHAR wzComputerName[MAX_COMPUTERNAME_LENGTH + 1] = { };
DWORD cchComputerName = countof(wzComputerName);
// get computer name
if (!::GetComputerNameW(wzComputerName, &cchComputerName))
{
ExitWithLastError(hr, "Failed to get computer name.");
}
// set value
hr = BVariantSetString(pValue, wzComputerName, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableVersionMsi(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
DLLGETVERSIONPROC pfnMsiDllGetVersion = NULL;
DLLVERSIONINFO msiVersionInfo = { };
VERUTIL_VERSION* pVersion = NULL;
// get DllGetVersion proc address
pfnMsiDllGetVersion = (DLLGETVERSIONPROC)::GetProcAddress(::GetModuleHandleW(L"msi"), "DllGetVersion");
ExitOnNullWithLastError(pfnMsiDllGetVersion, hr, "Failed to find DllGetVersion entry point in msi.dll.");
// get msi.dll version info
msiVersionInfo.cbSize = sizeof(DLLVERSIONINFO);
hr = pfnMsiDllGetVersion(&msiVersionInfo);
ExitOnFailure(hr, "Failed to get msi.dll version info.");
hr = VerVersionFromQword(MAKEQWORDVERSION(msiVersionInfo.dwMajorVersion, msiVersionInfo.dwMinorVersion, 0, 0), &pVersion);
ExitOnFailure(hr, "Failed to create msi.dll version from QWORD.");
hr = BVariantSetVersion(pValue, pVersion);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseVerutilVersion(pVersion);
return hr;
}
static HRESULT InitializeVariableCsidlFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LPWSTR sczPath = NULL;
int nFolder = (int)dwpData;
// get folder path
hr = ShelGetFolder(&sczPath, nFolder);
ExitOnRootFailure(hr, "Failed to get shell folder.");
// set value
hr = BVariantSetString(pValue, sczPath, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczPath);
return hr;
}
static HRESULT InitializeVariableTempFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
LPWSTR sczPath = NULL;
hr = PathGetTempPath(&sczPath, NULL);
ExitOnFailure(hr, "Failed to get temp path.");
// set value
hr = BVariantSetString(pValue, sczPath, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczPath);
return hr;
}
static HRESULT InitializeVariableSystemFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
BOOL f64 = (BOOL)dwpData;
LPWSTR sczSystemFolder = NULL;
#if !defined(_WIN64)
BOOL fIsWow64 = FALSE;
ProcWow64(::GetCurrentProcess(), &fIsWow64);
if (fIsWow64)
{
if (f64)
{
hr = PathGetSystemDirectory(&sczSystemFolder);
ExitOnFailure(hr, "Failed to get 64-bit system folder.");
}
else
{
hr = PathGetSystemWow64Directory(&sczSystemFolder);
ExitOnFailure(hr, "Failed to get 32-bit system folder.");
}
}
else
{
if (!f64)
{
hr = PathGetSystemDirectory(&sczSystemFolder);
ExitOnFailure(hr, "Failed to get 32-bit system folder.");
}
}
#else
if (f64)
{
hr = PathGetSystemDirectory(&sczSystemFolder);
ExitOnFailure(hr, "Failed to get 64-bit system folder.");
}
else
{
hr = PathGetSystemWow64Directory(&sczSystemFolder);
ExitOnFailure(hr, "Failed to get 32-bit system folder.");
}
#endif
// set value
hr = BVariantSetString(pValue, sczSystemFolder, 0, FALSE);
ExitOnFailure(hr, "Failed to set system folder variant value.");
LExit:
ReleaseStr(sczSystemFolder);
return hr;
}
static HRESULT InitializeVariableWindowsVolumeFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
LPWSTR sczWindowsPath = NULL;
LPWSTR sczVolumePath = NULL;
// get windows directory
hr = PathSystemWindowsSubdirectory(NULL, &sczWindowsPath);
ExitOnFailure(hr, "Failed to get windows directory.");
// get volume path name
hr = PathGetVolumePathName(sczWindowsPath, &sczVolumePath);
ExitOnFailure(hr, "Failed to get volume path name.");
// set value
hr = BVariantSetString(pValue, sczVolumePath, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczWindowsPath);
ReleaseStr(sczVolumePath);
return hr;
}
static HRESULT InitializeVariablePrivileged(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
BOOL fPrivileged = FALSE;
// check if process could run privileged.
hr = OsCouldRunPrivileged(&fPrivileged);
ExitOnFailure(hr, "Failed to check if process could run privileged.");
// set value
hr = BVariantSetNumeric(pValue, fPrivileged);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableProcessTokenPrivilege(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
BOOL fHasPrivilege = FALSE;
LPCWSTR wzPrivilegeName = (LPCWSTR)dwpData;
hr = ProcHasPrivilege(::GetCurrentProcess(), wzPrivilegeName, &fHasPrivilege);
ExitOnFailure(hr, "Failed to check if process token has privilege: %ls.", wzPrivilegeName);
// set value
hr = BVariantSetNumeric(pValue, fHasPrivilege);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeSystemLanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
LANGID langid = ::GetSystemDefaultLangID();
hr = BVariantSetNumeric(pValue, langid);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeUserUILanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
LANGID langid = ::GetUserDefaultUILanguage();
hr = BVariantSetNumeric(pValue, langid);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeUserLanguageID(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
UNREFERENCED_PARAMETER(dwpData);
HRESULT hr = S_OK;
LANGID langid = ::GetUserDefaultLangID();
hr = BVariantSetNumeric(pValue, langid);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableString(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LPCWSTR wzValue = (LPCWSTR)dwpData;
// set value
hr = BVariantSetString(pValue, wzValue, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableNumeric(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LONGLONG llValue = (LONGLONG)dwpData;
// set value
hr = BVariantSetNumeric(pValue, llValue);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
#if !defined(_WIN64)
static HRESULT InitializeVariableRegistryFolder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
int nFolder = (int)dwpData;
LPWSTR sczPath = NULL;
BOOL fIsWow64 = FALSE;
ProcWow64(::GetCurrentProcess(), &fIsWow64);
if (!fIsWow64) // on 32-bit machines, variables aren't set
{
ExitFunction();
}
hr = Get64bitFolderFromRegistry(nFolder, &sczPath);
ExitOnFailure(hr, "Failed to get 64-bit folder.");
// set value
hr = BVariantSetString(pValue, sczPath, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczPath);
return hr;
}
#endif
static HRESULT InitializeVariable6432Folder(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
int nFolder = (int)dwpData;
LPWSTR sczPath = NULL;
#if !defined(_WIN64)
BOOL fIsWow64 = FALSE;
// If 32-bit use shell-folder.
ProcWow64(::GetCurrentProcess(), &fIsWow64);
if (!fIsWow64)
{
hr = ShelGetFolder(&sczPath, nFolder);
ExitOnRootFailure(hr, "Failed to get shell folder.");
}
else
#endif
{
hr = Get64bitFolderFromRegistry(nFolder, &sczPath);
ExitOnFailure(hr, "Failed to get 64-bit folder.");
}
// set value
hr = BVariantSetString(pValue, sczPath, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczPath);
return hr;
}
// Get the date in the same format as Windows Installer.
static HRESULT InitializeVariableDate(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
SYSTEMTIME systime = { };
LPWSTR sczDate = NULL;
int cchDate = 0;
::GetSystemTime(&systime);
cchDate = ::GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime, NULL, NULL, cchDate);
if (!cchDate)
{
ExitOnLastError(hr, "Failed to get the required buffer length for the Date.");
}
hr = StrAlloc(&sczDate, cchDate);
ExitOnFailure(hr, "Failed to allocate the buffer for the Date.");
if (!::GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systime, NULL, sczDate, cchDate))
{
ExitOnLastError(hr, "Failed to get the Date.");
}
// set value
hr = BVariantSetString(pValue, sczDate, cchDate, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczDate);
return hr;
}
static HRESULT InitializeVariableInstallerName(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
// set value
hr = BVariantSetString(pValue, L"WiX Burn", 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT InitializeVariableInstallerVersion(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LPWSTR sczVersion = NULL;
hr = StrAllocStringAnsi(&sczVersion, szVerMajorMinorBuild, 0, CP_ACP);
ExitOnFailure(hr, "Failed to copy the engine version: %hs", szVerMajorMinorBuild);
// set value
hr = BVariantSetString(pValue, sczVersion, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczVersion);
return hr;
}
static HRESULT InitializeVariableInstallerInformationalVersion(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LPWSTR sczVersion = NULL;
hr = StrAllocStringAnsi(&sczVersion, szInformationalVersion, 0, CP_ACP);
ExitOnFailure(hr, "Failed to copy the engine informational version: %hs", szInformationalVersion);
// set value
hr = BVariantSetString(pValue, sczVersion, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseStr(sczVersion);
return hr;
}
static HRESULT InitializeVariableVersion(
__in DWORD_PTR dwpData,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
LPCWSTR wzValue = (LPCWSTR)dwpData;
VERUTIL_VERSION* pVersion = NULL;
hr = VerParseVersion(wzValue, 0, FALSE, &pVersion);
ExitOnFailure(hr, "Failed to initialize version.");
// set value
hr = BVariantSetVersion(pValue, pVersion);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
ReleaseVerutilVersion(pVersion);
return hr;
}
// Get the current user the same as Windows Installer.
static HRESULT InitializeVariableLogonUser(
__in DWORD_PTR /*dwpData*/,
__inout BURN_VARIANT* pValue
)
{
HRESULT hr = S_OK;
WCHAR wzUserName[UNLEN + 1];
DWORD cchUserName = countof(wzUserName);
if (!::GetUserNameW(wzUserName, &cchUserName))
{
ExitOnLastError(hr, "Failed to get the user name.");
}
// set value
hr = BVariantSetString(pValue, wzUserName, 0, FALSE);
ExitOnFailure(hr, "Failed to set variant value.");
LExit:
return hr;
}
static HRESULT Get64bitFolderFromRegistry(
__in int nFolder,
__deref_out_z LPWSTR* psczPath
)
{
HRESULT hr = S_OK;
HKEY hkFolders = NULL;
AssertSz(CSIDL_PROGRAM_FILES == nFolder || CSIDL_PROGRAM_FILES_COMMON == nFolder, "Unknown folder CSIDL.");
LPCWSTR wzFolderValue = CSIDL_PROGRAM_FILES_COMMON == nFolder ? L"CommonFilesDir" : L"ProgramFilesDir";
hr = RegOpenEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion", KEY_READ, REG_KEY_64BIT, &hkFolders);
ExitOnFailure(hr, "Failed to open Windows folder key.");
hr = RegReadString(hkFolders, wzFolderValue, psczPath);
ExitOnFailure(hr, "Failed to read folder path for '%ls'.", wzFolderValue);
hr = PathBackslashTerminate(psczPath);
ExitOnFailure(hr, "Failed to ensure path was backslash terminated.");
LExit:
ReleaseRegKey(hkFolders);
return hr;
}