path: root/src/dtf/SfxCA/SfxUtil.cpp

// 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"
#include "SfxUtil.h"

#define GUID_STRING_LENGTH 39

/// <summary>
/// Writes a formatted message to the MSI log.
/// Does out-of-proc MSI calls if necessary.
/// </summary>
void Log(MSIHANDLE hSession, const wchar_t* szMessage, ...)
{
        const int LOG_BUFSIZE = 4096;
        wchar_t szBuf[LOG_BUFSIZE];
        va_list args;
        va_start(args, szMessage);
        StringCchVPrintf(szBuf, LOG_BUFSIZE, szMessage, args);

        if (!g_fRunningOutOfProc || NULL == g_pRemote)
        {
                MSIHANDLE hRec = MsiCreateRecord(1);
                MsiRecordSetString(hRec, 0, L"SFXCA: [1]");
                MsiRecordSetString(hRec, 1, szBuf);
                MsiProcessMessage(hSession, INSTALLMESSAGE_INFO, hRec);
                MsiCloseHandle(hRec);
        }
        else
        {
                // Logging is the only remote-MSI operation done from unmanaged code.
                // It's not very convenient here because part of the infrastructure
                // for remote MSI APIs is on the managed side.

                RemoteMsiSession::RequestData req;
                RemoteMsiSession::RequestData* pResp = NULL;
                SecureZeroMemory(&req, sizeof(RemoteMsiSession::RequestData));

                req.fields[0].vt = VT_UI4;
                req.fields[0].uiValue = 1;
                g_pRemote->SendRequest(RemoteMsiSession::MsiCreateRecord, &req, &pResp);
                MSIHANDLE hRec = (MSIHANDLE) pResp->fields[0].iValue;

                req.fields[0].vt = VT_I4;
                req.fields[0].iValue = (int) hRec;
                req.fields[1].vt = VT_UI4;
                req.fields[1].uiValue = 0;
                req.fields[2].vt = VT_LPWSTR;
                req.fields[2].szValue = L"SFXCA: [1]";
                g_pRemote->SendRequest(RemoteMsiSession::MsiRecordSetString, &req, &pResp);

                req.fields[0].vt = VT_I4;
                req.fields[0].iValue = (int) hRec;
                req.fields[1].vt = VT_UI4;
                req.fields[1].uiValue = 1;
                req.fields[2].vt = VT_LPWSTR;
                req.fields[2].szValue = szBuf;
                g_pRemote->SendRequest(RemoteMsiSession::MsiRecordSetString, &req, &pResp);

                req.fields[0].vt = VT_I4;
                req.fields[0].iValue = (int) hSession;
                req.fields[1].vt = VT_I4;
                req.fields[1].iValue = (int) INSTALLMESSAGE_INFO;
                req.fields[2].vt = VT_I4;
                req.fields[2].iValue = (int) hRec;
                g_pRemote->SendRequest(RemoteMsiSession::MsiProcessMessage, &req, &pResp);

                req.fields[0].vt = VT_I4;
                req.fields[0].iValue = (int) hRec;
                req.fields[1].vt = VT_EMPTY;
                req.fields[2].vt = VT_EMPTY;
                g_pRemote->SendRequest(RemoteMsiSession::MsiCloseHandle, &req, &pResp);
        }
}

/// <summary>
/// Deletes a directory, including all files and subdirectories.
/// </summary>
/// <param name="szDir">Path to the directory to delete,
/// not including a trailing backslash.</param>
/// <returns>True if the directory was successfully deleted, or false
/// if the deletion failed (most likely because some files were locked).
/// </returns>
bool DeleteDirectory(const wchar_t* szDir)
{
        size_t cchDir = wcslen(szDir);
        size_t cchPathBuf = cchDir + 3 + MAX_PATH;
        wchar_t* szPath = (wchar_t*) _alloca(cchPathBuf * sizeof(wchar_t));
        if (szPath == NULL) return false;
        StringCchCopy(szPath, cchPathBuf, szDir);
        StringCchCat(szPath, cchPathBuf, L"\\*");
        WIN32_FIND_DATA fd;
        HANDLE hSearch = FindFirstFile(szPath, &fd);
        while (hSearch != INVALID_HANDLE_VALUE)
        {
                StringCchCopy(szPath + cchDir + 1, cchPathBuf - (cchDir + 1), fd.cFileName);
                if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
                {
                        if (wcscmp(fd.cFileName, L".") != 0
                            && wcscmp(fd.cFileName, L"..") != 0
                            && ((fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) == 0))
                        {
                                DeleteDirectory(szPath);
                        }
                }
                else
                {
                        DeleteFile(szPath);
                }
                if (!FindNextFile(hSearch, &fd))
                {
                        FindClose(hSearch);
                        hSearch = INVALID_HANDLE_VALUE;
                }
        }

        for (int i = 0; i < 3; i++)
        {
            if (::RemoveDirectory(szDir))
            {
                return true;
            }

            ::Sleep(100);
        }

        return false;
}

static HRESULT CreateGuid(
    _Out_z_cap_c_(GUID_STRING_LENGTH) wchar_t* wzGuid)
{
        HRESULT hr = S_OK;
        RPC_STATUS rs = RPC_S_OK;
        UUID guid = {};

        rs = ::UuidCreate(&guid);
        if (rs != RPC_S_OK)
        {
                hr = (HRESULT)(rs | FACILITY_RPC);
        }
        else if (!::StringFromGUID2(guid, wzGuid, GUID_STRING_LENGTH))
        {
                hr = E_OUTOFMEMORY;
        }
        else // make the temp directory more recognizable for easy deletion.
        {
                // Copy the first four hex chars of the GUID over the dashes in the GUID and trim the, so
                // '{1234ABCD-ABCD-ABCD-ABCD-ABCDABCDABCD}' turns into '{1234ABCD1ABCD2ABCD3ABCD4ABCDABCDABCD}'
                wzGuid[9] = wzGuid[1];
                wzGuid[14] = wzGuid[2];
                wzGuid[19] = wzGuid[3];
                wzGuid[24] = wzGuid[4];

                // Now '{1234ABCD1ABCD2ABCD3ABCD4ABCDABCDABCD}' turns into 'SFXCAABCD1ABCD2ABCD3ABCD4ABCDABCDABCD'
                wzGuid[0] = L'S';
                wzGuid[1] = L'F';
                wzGuid[2] = L'X';
                wzGuid[3] = L'C';
                wzGuid[4] = L'A';
                wzGuid[GUID_STRING_LENGTH - 2] = L'\0';
        }

        return hr;
}

static HRESULT ProcessElevated()
{
        HRESULT hr = S_OK;
        HANDLE hToken = NULL;
        TOKEN_ELEVATION tokenElevated = {};
        DWORD cbToken = 0;

        if (::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY, &hToken) &&
            ::GetTokenInformation(hToken, TokenElevation, &tokenElevated, sizeof(TOKEN_ELEVATION), &cbToken))
        {
                hr = (0 != tokenElevated.TokenIsElevated) ? S_OK : S_FALSE;
        }
        else
        {
                hr = HRESULT_FROM_WIN32(::GetLastError());
        }

        return hr;
}

/// <summary>
/// Extracts a cabinet that is concatenated to a module
/// to a new temporary directory.
/// </summary>
/// <param name="hSession">Handle to the installer session,
/// used just for logging.</param>
/// <param name="hModule">Module that has the concatenated cabinet.</param>
/// <param name="szTempDir">Buffer for returning the path of the
/// created temp directory.</param>
/// <param name="cchTempDirBuf">Size in characters of the buffer.
/// <returns>True if the files were extracted, or false if the
/// buffer was too small or the directory could not be created
/// or the extraction failed for some other reason.</returns>
__success(return != false)
bool ExtractToTempDirectory(__in MSIHANDLE hSession, __in HMODULE hModule,
        __out_ecount_z(cchTempDirBuf) wchar_t* szTempDir, DWORD cchTempDirBuf)
{
        HRESULT hr = S_OK;
        wchar_t szModule[MAX_PATH] = {};
        wchar_t szGuid[GUID_STRING_LENGTH] = {};

        DWORD cchCopied = ::GetModuleFileName(hModule, szModule, MAX_PATH - 1);
        if (cchCopied == 0 || cchCopied == MAX_PATH - 1)
        {
                hr = HRESULT_FROM_WIN32(::GetLastError());
                if (SUCCEEDED(hr))
                {
                        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
                }

                Log(hSession, L"Failed to get module path. Error code 0x%x.", hr);
                goto LExit;
        }

        hr = CreateGuid(szGuid);
        if (FAILED(hr))
        {
                Log(hSession, L"Failed to create a GUID. Error code 0x%x", hr);
                goto LExit;
        }

        // Unelevated we use the user's temp directory.
        hr = ProcessElevated();
        if (S_FALSE == hr)
        {
                // Temp path is documented to be returned with a trailing backslash.
                cchCopied = ::GetTempPath(cchTempDirBuf, szTempDir);
                if (cchCopied == 0 || cchCopied >= cchTempDirBuf)
                {
                        hr = HRESULT_FROM_WIN32(::GetLastError());
                        if (SUCCEEDED(hr))
                        {
                                hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
                        }

                        Log(hSession, L"Failed to get user temp directory. Error code 0x%x", hr);
                        goto LExit;
                }
        }
        else // elevated or we couldn't check (in the latter case, assume we're elevated since it's safer to use)
        {
                // Windows directory will not contain a trailing backslash, so we add it next.
                cchCopied = ::GetWindowsDirectoryW(szTempDir, cchTempDirBuf);
                if (cchCopied == 0 || cchCopied >= cchTempDirBuf)
                {
                        hr = HRESULT_FROM_WIN32(::GetLastError());
                        if (SUCCEEDED(hr))
                        {
                                hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
                        }

                        Log(hSession, L"Failed to get Windows directory. Error code 0x%x", hr);
                        goto LExit;
                }

                hr = ::StringCchCat(szTempDir, cchTempDirBuf, L"\\Installer\\");
                if (FAILED(hr))
                {
                        Log(hSession, L"Failed append 'Installer' to Windows directory. Error code 0x%x", hr);
                        goto LExit;
                }
        }

        hr = ::StringCchCat(szTempDir, cchTempDirBuf, szGuid);
        if (FAILED(hr))
        {
                Log(hSession, L"Failed append GUID to temp path. Error code 0x%x", hr);
                goto LExit;
        }

        if (!::CreateDirectory(szTempDir, NULL))
        {
                hr = HRESULT_FROM_WIN32(::GetLastError());
                Log(hSession, L"Failed to create temp directory. Error code 0x%x", hr);
                goto LExit;
        }

        Log(hSession, L"Extracting custom action to temporary directory: %s\\", szTempDir);
        int err = ExtractCabinet(szModule, szTempDir);
        if (err != 0)
        {
                hr = E_FAIL;
                Log(hSession, L"Failed to extract to temporary directory. Cabinet error code %d.", err);
                DeleteDirectory(szTempDir);
        }

LExit:
        return SUCCEEDED(hr);
}