Import code from old v4 repo

1 files changed, 271 insertions, 0 deletions

diff --git a/src/engine/pseudobundle.cpp b/src/engine/pseudobundle.cpp
new file mode 100644
index 00000000..ebdc040a
--- /dev/null
+++ b/src/engine/pseudobundle.cpp
@@ -0,0 +1,271 @@
+// 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"
+
+
+extern "C" HRESULT PseudoBundleInitialize(
+    __in DWORD64 qwEngineVersion,
+    __in BURN_PACKAGE* pPackage,
+    __in BOOL fPerMachine,
+    __in_z LPCWSTR wzId,
+    __in BOOTSTRAPPER_RELATION_TYPE relationType,
+    __in BOOTSTRAPPER_PACKAGE_STATE state,
+    __in_z LPCWSTR wzFilePath,
+    __in_z LPCWSTR wzLocalSource,
+    __in_z_opt LPCWSTR wzDownloadSource,
+    __in DWORD64 qwSize,
+    __in BOOL fVital,
+    __in_z_opt LPCWSTR wzInstallArguments,
+    __in_z_opt LPCWSTR wzRepairArguments,
+    __in_z_opt LPCWSTR wzUninstallArguments,
+    __in_opt BURN_DEPENDENCY_PROVIDER* pDependencyProvider,
+    __in_opt BYTE* pbHash,
+    __in DWORD cbHash
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczRelationTypeCommandLineSwitch = NULL;
+
+    LPCWSTR wzRelationTypeCommandLine = CoreRelationTypeToCommandLineString(relationType);
+    if (wzRelationTypeCommandLine)
+    {
+        hr = StrAllocFormatted(&sczRelationTypeCommandLineSwitch, L" -%ls", wzRelationTypeCommandLine);
+    }
+
+    // Initialize the single payload, and fill out all the necessary fields
+    pPackage->rgPayloads = (BURN_PACKAGE_PAYLOAD *)MemAlloc(sizeof(BURN_PACKAGE_PAYLOAD), TRUE); 
+    ExitOnNull(pPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn package payload inside of related bundle struct");
+    pPackage->cPayloads = 1;
+
+    pPackage->rgPayloads->pPayload = (BURN_PAYLOAD *)MemAlloc(sizeof(BURN_PAYLOAD), TRUE); 
+    ExitOnNull(pPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn payload inside of related bundle struct");
+    pPackage->rgPayloads->pPayload->packaging = BURN_PAYLOAD_PACKAGING_EXTERNAL;
+    pPackage->rgPayloads->pPayload->qwFileSize = qwSize;
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczKey, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy key for pseudo bundle payload.");
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczFilePath, wzFilePath, 0);
+    ExitOnFailure(hr, "Failed to copy filename for pseudo bundle.");
+
+    hr = StrAllocString(&pPackage->rgPayloads->pPayload->sczSourcePath, wzLocalSource, 0);
+    ExitOnFailure(hr, "Failed to copy local source path for pseudo bundle.");
+
+    if (wzDownloadSource && *wzDownloadSource)
+    {
+        hr = StrAllocString(&pPackage->rgPayloads->pPayload->downloadSource.sczUrl, wzDownloadSource, 0);
+        ExitOnFailure(hr, "Failed to copy download source for pseudo bundle.");
+    }
+
+    if (pbHash)
+    {
+        pPackage->rgPayloads->pPayload->pbHash = static_cast<BYTE*>(MemAlloc(cbHash, FALSE));
+        ExitOnNull(pPackage->rgPayloads->pPayload->pbHash, hr, E_OUTOFMEMORY, "Failed to allocate memory for pseudo bundle payload hash.");
+
+        pPackage->rgPayloads->pPayload->cbHash = cbHash;
+        memcpy_s(pPackage->rgPayloads->pPayload->pbHash, pPackage->rgPayloads->pPayload->cbHash, pbHash, cbHash);
+    }
+
+    pPackage->rgPayloads->fCached = (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == state || BOOTSTRAPPER_PACKAGE_STATE_CACHED == state);
+
+    pPackage->Exe.fPseudoBundle = TRUE;
+
+    pPackage->type = BURN_PACKAGE_TYPE_EXE;
+    pPackage->fPerMachine = fPerMachine;
+    pPackage->currentState = state;
+    pPackage->cache = (BOOTSTRAPPER_PACKAGE_STATE_PRESENT == state || BOOTSTRAPPER_PACKAGE_STATE_CACHED == state) ? BURN_CACHE_STATE_COMPLETE : BURN_CACHE_STATE_NONE;
+    pPackage->qwInstallSize = qwSize;
+    pPackage->qwSize = qwSize;
+    pPackage->fVital = fVital;
+
+    hr = StrAllocString(&pPackage->sczId, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+    hr = StrAllocString(&pPackage->sczCacheId, wzId, 0);
+    ExitOnFailure(hr, "Failed to copy cache id for pseudo bundle.");
+
+    // If we are a self updating bundle, we don't have to have Install arguments.
+    if (wzInstallArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczInstallArguments, wzInstallArguments, 0);
+        ExitOnFailure(hr, "Failed to copy install arguments for related bundle package");
+    }
+
+    if (sczRelationTypeCommandLineSwitch)
+    {
+        hr = StrAllocConcat(&pPackage->Exe.sczInstallArguments, sczRelationTypeCommandLineSwitch, 0);
+        ExitOnFailure(hr, "Failed to append relation type to install arguments for related bundle package");
+    }
+
+    if (wzRepairArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczRepairArguments, wzRepairArguments, 0);
+        ExitOnFailure(hr, "Failed to copy repair arguments for related bundle package");
+
+        if (sczRelationTypeCommandLineSwitch)
+        {
+            hr = StrAllocConcat(&pPackage->Exe.sczRepairArguments, sczRelationTypeCommandLineSwitch, 0);
+            ExitOnFailure(hr, "Failed to append relation type to repair arguments for related bundle package");
+        }
+
+        pPackage->Exe.fRepairable = TRUE;
+    }
+
+    if (wzUninstallArguments)
+    {
+        hr = StrAllocString(&pPackage->Exe.sczUninstallArguments, wzUninstallArguments, 0);
+        ExitOnFailure(hr, "Failed to copy uninstall arguments for related bundle package");
+
+        if (sczRelationTypeCommandLineSwitch)
+        {
+            hr = StrAllocConcat(&pPackage->Exe.sczUninstallArguments, sczRelationTypeCommandLineSwitch, 0);
+            ExitOnFailure(hr, "Failed to append relation type to uninstall arguments for related bundle package");
+        }
+
+        pPackage->fUninstallable = TRUE;
+    }
+
+    // Only support progress from engines that are compatible (aka: version greater than or equal to last protocol breaking change *and* versions that are older or the same as this engine).
+    pPackage->Exe.protocol = (FILEMAKEVERSION(3, 6, 2221, 0) <= qwEngineVersion && qwEngineVersion <= FILEMAKEVERSION(rmj, rmm, rup, 0)) ? BURN_EXE_PROTOCOL_TYPE_BURN : BURN_EXE_PROTOCOL_TYPE_NONE;
+    
+    // All versions of Burn past v3.9 RTM support suppressing ancestors.
+    pPackage->Exe.fSupportsAncestors = FILEMAKEVERSION(3, 9, 1006, 0) <= qwEngineVersion;
+
+    if (pDependencyProvider)
+    {
+        pPackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER), TRUE);
+        ExitOnNull(pPackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate memory for dependency providers.");
+        pPackage->cDependencyProviders = 1;
+
+        pPackage->rgDependencyProviders[0].fImported = pDependencyProvider->fImported;
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczKey, pDependencyProvider->sczKey, 0);
+        ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczVersion, pDependencyProvider->sczVersion, 0);
+        ExitOnFailure(hr, "Failed to copy version for pseudo bundle.");
+
+        hr = StrAllocString(&pPackage->rgDependencyProviders[0].sczDisplayName, pDependencyProvider->sczDisplayName, 0);
+        ExitOnFailure(hr, "Failed to copy display name for pseudo bundle.");
+    }
+
+LExit:
+    ReleaseStr(sczRelationTypeCommandLineSwitch);
+
+    return hr;
+}
+
+extern "C" HRESULT PseudoBundleInitializePassthrough(
+    __in BURN_PACKAGE* pPassthroughPackage,
+    __in BOOTSTRAPPER_COMMAND* pCommand,
+    __in_z_opt LPCWSTR wzAppendLogPath,
+    __in_z_opt LPWSTR wzActiveParent,
+    __in_z_opt LPWSTR wzAncestors,
+    __in BURN_PACKAGE* pPackage
+    )
+{
+    Assert(BURN_PACKAGE_TYPE_EXE == pPackage->type);
+
+    HRESULT hr = S_OK;
+    LPWSTR sczArguments = NULL;
+
+    // Initialize the payloads, and copy the necessary fields.
+    pPassthroughPackage->rgPayloads = (BURN_PACKAGE_PAYLOAD *)MemAlloc(sizeof(BURN_PACKAGE_PAYLOAD) * pPackage->cPayloads, TRUE);
+    ExitOnNull(pPassthroughPackage->rgPayloads, hr, E_OUTOFMEMORY, "Failed to allocate space for burn package payload inside of passthrough bundle.");
+    pPassthroughPackage->cPayloads = pPackage->cPayloads;
+
+    for (DWORD iPayload = 0; iPayload < pPackage->cPayloads; ++iPayload)
+    {
+        BURN_PACKAGE_PAYLOAD* pPayload = pPackage->rgPayloads + iPayload;
+
+        pPassthroughPackage->rgPayloads[iPayload].pPayload = (BURN_PAYLOAD *)MemAlloc(sizeof(BURN_PAYLOAD), TRUE); 
+        ExitOnNull(pPassthroughPackage->rgPayloads[iPayload].pPayload, hr, E_OUTOFMEMORY, "Failed to allocate space for burn payload inside of related bundle struct");
+        pPassthroughPackage->rgPayloads[iPayload].pPayload->packaging = pPayload->pPayload->packaging;
+        pPassthroughPackage->rgPayloads[iPayload].pPayload->qwFileSize = pPayload->pPayload->qwFileSize;
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczKey, pPayload->pPayload->sczKey, 0);
+        ExitOnFailure(hr, "Failed to copy key for passthrough pseudo bundle payload.");
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczFilePath, pPayload->pPayload->sczFilePath, 0);
+        ExitOnFailure(hr, "Failed to copy filename for passthrough pseudo bundle.");
+
+        hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->sczSourcePath, pPayload->pPayload->sczSourcePath, 0);
+        ExitOnFailure(hr, "Failed to copy local source path for passthrough pseudo bundle.");
+
+        if (pPayload->pPayload->downloadSource.sczUrl)
+        {
+            hr = StrAllocString(&pPassthroughPackage->rgPayloads[iPayload].pPayload->downloadSource.sczUrl, pPayload->pPayload->downloadSource.sczUrl, 0);
+            ExitOnFailure(hr, "Failed to copy download source for passthrough pseudo bundle.");
+        }
+
+        if (pPayload->pPayload->pbHash)
+        {
+            pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash = static_cast<BYTE*>(MemAlloc(pPayload->pPayload->cbHash, FALSE));
+            ExitOnNull(pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash, hr, E_OUTOFMEMORY, "Failed to allocate memory for pseudo bundle payload hash.");
+
+            pPassthroughPackage->rgPayloads[iPayload].pPayload->cbHash = pPayload->pPayload->cbHash;
+            memcpy_s(pPassthroughPackage->rgPayloads[iPayload].pPayload->pbHash, pPassthroughPackage->rgPayloads[iPayload].pPayload->cbHash, pPayload->pPayload->pbHash, pPayload->pPayload->cbHash);
+        }
+
+        pPassthroughPackage->rgPayloads[iPayload].fCached = pPayload->fCached;
+    }
+
+    pPassthroughPackage->Exe.fPseudoBundle = TRUE;
+
+    pPassthroughPackage->fPerMachine = FALSE; // passthrough bundles are always launched per-user.
+    pPassthroughPackage->type = pPackage->type;
+    pPassthroughPackage->currentState = pPackage->currentState;
+    pPassthroughPackage->cache = pPackage->cache;
+    pPassthroughPackage->qwInstallSize = pPackage->qwInstallSize;
+    pPassthroughPackage->qwSize = pPackage->qwSize;
+    pPassthroughPackage->fVital = pPackage->fVital;
+
+    hr = StrAllocString(&pPassthroughPackage->sczId, pPackage->sczId, 0);
+    ExitOnFailure(hr, "Failed to copy key for passthrough pseudo bundle.");
+
+    hr = StrAllocString(&pPassthroughPackage->sczCacheId, pPackage->sczCacheId, 0);
+    ExitOnFailure(hr, "Failed to copy cache id for passthrough pseudo bundle.");
+
+    pPassthroughPackage->Exe.protocol = pPackage->Exe.protocol;
+
+    // No matter the operation, we're passing the same command-line. That's what makes
+    // this a passthrough bundle.
+    hr = CoreRecreateCommandLine(&sczArguments, pCommand->action, pCommand->display, pCommand->restart, pCommand->relationType, TRUE, wzActiveParent, wzAncestors, wzAppendLogPath, pCommand->wzCommandLine);
+    ExitOnFailure(hr, "Failed to recreate command-line arguments.");
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczInstallArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy install arguments for passthrough bundle package");
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczRepairArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy related arguments for passthrough bundle package");
+
+    pPassthroughPackage->Exe.fRepairable = TRUE;
+
+    hr = StrAllocString(&pPassthroughPackage->Exe.sczUninstallArguments, sczArguments, 0);
+    ExitOnFailure(hr, "Failed to copy uninstall arguments for passthrough bundle package");
+
+    pPassthroughPackage->fUninstallable = TRUE;
+
+    // TODO: consider bringing this back in the near future.
+    //if (pDependencyProvider)
+    //{
+    //    pPassthroughPackage->rgDependencyProviders = (BURN_DEPENDENCY_PROVIDER*)MemAlloc(sizeof(BURN_DEPENDENCY_PROVIDER), TRUE);
+    //    ExitOnNull(pPassthroughPackage->rgDependencyProviders, hr, E_OUTOFMEMORY, "Failed to allocate memory for dependency providers.");
+    //    pPassthroughPackage->cDependencyProviders = 1;
+
+    //    pPassthroughPackage->rgDependencyProviders[0].fImported = pDependencyProvider->fImported;
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczKey, pDependencyProvider->sczKey, 0);
+    //    ExitOnFailure(hr, "Failed to copy key for pseudo bundle.");
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczVersion, pDependencyProvider->sczVersion, 0);
+    //    ExitOnFailure(hr, "Failed to copy version for pseudo bundle.");
+
+    //    hr = StrAllocString(&pPassthroughPackage->rgDependencyProviders[0].sczDisplayName, pDependencyProvider->sczDisplayName, 0);
+    //    ExitOnFailure(hr, "Failed to copy display name for pseudo bundle.");
+    //}
+
+LExit:
+    ReleaseStr(sczArguments);
+    return hr;
+}