b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

d0a16c48f3477794c63f4ff3242dc20db6a49295Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <windows.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <msiquery.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <objbase.h>

d0a16c48f3477794c63f4ff3242dc20db6a49295Satyen Desai#include <shlobj.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <stdlib.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <stdio.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <string.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <strsafe.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

d0a16c48f3477794c63f4ff3242dc20db6a49295Satyen Desai#include <VBox/version.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/assert.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/dir.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/file.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/initterm.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/mem.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/path.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/param.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/string.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include <iprt/thread.h>

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include "VBoxStub.h"

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include "../StubBld/VBoxStubBld.h"

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#include "resource.h"

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

d0a16c48f3477794c63f4ff3242dc20db6a49295Satyen Desai#ifndef _UNICODE

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai#define _UNICODE

d0a16c48f3477794c63f4ff3242dc20db6a49295Satyen Desai#endif

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desaistatic int ShowInfo(const char *pszFmt, ...)

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai{

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai char *pszMsg;

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai va_list va;

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

ac183771e1b6ff195ceab9bbfa6e51bc15cb4c04Satyen Desai va_start(va, pszFmt);

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai RTStrAPrintfV(&pszMsg, pszFmt, va);

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai va_end(va);

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai int rc;

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai if (pszMsg)

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai rc = MessageBox(GetDesktopWindow(), pszMsg, VBOX_STUB_TITLE, MB_ICONINFORMATION);

ac183771e1b6ff195ceab9bbfa6e51bc15cb4c04Satyen Desai else

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai rc = MessageBox(GetDesktopWindow(), pszFmt, VBOX_STUB_TITLE, MB_ICONINFORMATION);

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai RTStrFree(pszMsg);

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai return rc;

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai}

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desaistatic int ShowError(const char *pszFmt, ...)

b1c2d1f8735dc44a6c1a80f77447293503d5a054Satyen Desai{

char *pszMsg;

va_list va;

va_start(va, pszFmt);

RTStrAPrintfV(&pszMsg, pszFmt, va);

va_end(va);

int rc;

if (pszMsg)

rc = MessageBox(GetDesktopWindow(), pszMsg, VBOX_STUB_TITLE, MB_ICONERROR);

else

rc = MessageBox(GetDesktopWindow(), pszFmt, VBOX_STUB_TITLE, MB_ICONERROR);

RTStrFree(pszMsg);

return rc;

}

static int ReadData(HINSTANCE hInst,

const char *pszDataName,

PVOID *ppvResource,

DWORD *pdwSize)

{

do

{

AssertMsgBreak(pszDataName, ("Resource name is empty!\n"));

/* Find our resource. */

HRSRC hRsrc = FindResourceEx(hInst, RT_RCDATA, pszDataName, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));

AssertMsgBreak(hRsrc, ("Could not find resource!\n"));

/* Get resource size. */

*pdwSize = SizeofResource(hInst, hRsrc);

AssertMsgBreak((*pdwSize > 0, "Size of resource is invalid!\n"));

/* Get pointer to resource. */

HGLOBAL hData = LoadResource(hInst, hRsrc);

AssertMsgBreak(hData, ("Could not load resource!\n"));

/* Lock resource. */

*ppvResource = LockResource(hData);

AssertMsgBreak(*ppvResource, ("Could not lock resource!\n"));

return VINF_SUCCESS;

} while (0);

return VERR_IO_GEN_FAILURE;

}

static int GetTempFileAlloc(const char *pszTempPath,

const char *pszTargetFileName,

char **ppszTempFile)

{

if (RTStrAPrintf(ppszTempFile, "%s\\%s", pszTempPath, pszTargetFileName) >= 0)

return VINF_SUCCESS;

return VERR_NO_STR_MEMORY;

}

static int ExtractFile(const char *pszResourceName,

const char *pszTempFile)

{

int rc;

RTFILE fh;

BOOL bCreatedFile = FALSE;

do

{

AssertMsgBreak(pszResourceName, ("Resource pointer invalid!\n"));

AssertMsgBreak(pszTempFile, ("Temp file pointer invalid!"));

/* Read the data of the built-in resource. */

PVOID pvData = NULL;

DWORD dwDataSize = 0;

rc = ReadData(NULL, pszResourceName, &pvData, &dwDataSize);

AssertMsgRCBreak(rc, ("Could not read resource data!\n"));

/* Create new (and replace an old) file. */

rc = RTFileOpen(&fh, pszTempFile,

RTFILE_O_CREATE_REPLACE

| RTFILE_O_WRITE

| RTFILE_O_DENY_NOT_DELETE

| RTFILE_O_DENY_WRITE);

AssertMsgRCBreak(rc, ("Could not open file for writing!\n"));

bCreatedFile = TRUE;

/* Write contents to new file. */

size_t cbWritten = 0;

rc = RTFileWrite(fh, pvData, dwDataSize, &cbWritten);

AssertMsgRCBreak(rc, ("Could not open file for writing!\n"));

AssertMsgBreak(dwDataSize == cbWritten, ("File was not extracted completely! Disk full?\n"));

} while (0);

if (RTFileIsValid(fh))

RTFileClose(fh);

if (RT_FAILURE(rc))

{

if (bCreatedFile)

RTFileDelete(pszTempFile);

}

return rc;

}

static int Extract(const PVBOXSTUBPKG pPackage,

const char *pszTempFile)

{

return ExtractFile(pPackage->szResourceName,

pszTempFile);

}

static BOOL IsWow64(void)

{

BOOL bIsWow64 = TRUE;

fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle(TEXT("kernel32")), "IsWow64Process");

if (NULL != fnIsWow64Process)

{

if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64))

{

/* Error in retrieving process type - assume that we're running on 32bit. */

return FALSE;

}

}

return bIsWow64;

}

static BOOL PackageIsNeeded(PVBOXSTUBPKG pPackage)

{

BOOL bIsWow64 = IsWow64();

if ((bIsWow64 && pPackage->byArch == VBOXSTUBPKGARCH_AMD64)) /* 64bit Windows. */

{

return TRUE;

}

else if ((!bIsWow64 && pPackage->byArch == VBOXSTUBPKGARCH_X86)) /* 32bit. */

{

return TRUE;

}

else if (pPackage->byArch == VBOXSTUBPKGARCH_ALL)

{

return TRUE;

}

return FALSE;

}

int CopyDir(const char *pszDestDir, const char *pszSourceDir)

{

char szDest[_MAX_PATH + 1];

char szSource[_MAX_PATH + 1];

AssertStmt(pszDestDir, "Destination directory invalid!");

AssertStmt(pszSourceDir, "Source directory invalid!");

SHFILEOPSTRUCT s = {0};

if ( RTStrPrintf(szDest, _MAX_PATH, "%s%c", pszDestDir, '\0') > 0

&& RTStrPrintf(szSource, _MAX_PATH, "%s%c", pszSourceDir, '\0') > 0)

{

s.hwnd = NULL;

s.wFunc = FO_COPY;

s.pTo = szDest;

s.pFrom = szSource;

s.fFlags = FOF_SILENT |

FOF_NOCONFIRMATION |

FOF_NOCONFIRMMKDIR |

FOF_NOERRORUI;

}

return RTErrConvertFromWin32(SHFileOperation(&s));

}

int WINAPI WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

char *lpCmdLine,

int nCmdShow)

{

char **pArgV = __argv;

int iArgC = __argc;

/* Check if we're already running and jump out if so. */

/* Do not use a global namespace ("Global\\") for mutex name here, will blow up NT4 compatibility! */

HANDLE hMutexAppRunning = CreateMutex (NULL, FALSE, "VBoxStubInstaller");

if ( (hMutexAppRunning != NULL)

&& (GetLastError() == ERROR_ALREADY_EXISTS))

{

/* Close the mutex for this application instance. */

CloseHandle(hMutexAppRunning);

hMutexAppRunning = NULL;

return 1;

}

/* Init IPRT. */

int vrc = RTR3Init();

if (RT_FAILURE(vrc))

return vrc;

BOOL fExtractOnly = FALSE;

BOOL fSilent = FALSE;

BOOL fEnableLogging = FALSE;

BOOL bExit = FALSE;

/* Temp variables for arguments. */

char szExtractPath[RTPATH_MAX] = {0};

char szMSIArgs[RTPATH_MAX] = {0};

/* Process arguments. */

for (int i = 0; i < iArgC; i++)

{

if ( (0 == RTStrICmp(pArgV[i], "-x"))

|| (0 == RTStrICmp(pArgV[i], "-extract"))

|| (0 == RTStrICmp(pArgV[i], "/extract")))

{

fExtractOnly = TRUE;

}

else if ( (0 == RTStrICmp(pArgV[i], "-s"))

|| (0 == RTStrICmp(pArgV[i], "-silent"))

|| (0 == RTStrICmp(pArgV[i], "/silent")))

{

fSilent = TRUE;

}

else if ( (0 == RTStrICmp(pArgV[i], "-l"))

|| (0 == RTStrICmp(pArgV[i], "-logging"))

|| (0 == RTStrICmp(pArgV[i], "/logging")))

{

fEnableLogging = TRUE;

}

else if (( (0 == RTStrICmp(pArgV[i], "-p"))

|| (0 == RTStrICmp(pArgV[i], "-path"))

|| (0 == RTStrICmp(pArgV[i], "/path")))

&& (iArgC > i))

{

vrc = ::StringCbCat(szExtractPath, sizeof(szExtractPath), pArgV[i+1]);

i++; /* Avoid the specify path from being parsed */

}

else if (( (0 == RTStrICmp(pArgV[i], "-msiparams"))

|| (0 == RTStrICmp(pArgV[i], "/msiparams")))

&& (iArgC > i))

{

for (int a=i+1; a<iArgC; a++)

{

if (a > i+1) /* Insert a space. */

vrc = ::StringCbCat(szMSIArgs, sizeof(szMSIArgs), " ");

vrc = ::StringCbCat(szMSIArgs, sizeof(szMSIArgs), pArgV[a]);

}

}

else if ( (0 == RTStrICmp(pArgV[i], "-v"))

|| (0 == RTStrICmp(pArgV[i], "-version"))

|| (0 == RTStrICmp(pArgV[i], "/version")))

{

ShowInfo("Version: %d.%d.%d.%d",

VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD, VBOX_SVN_REV);

bExit = TRUE;

}

else if ( (0 == RTStrICmp(pArgV[i], "-help"))

|| (0 == RTStrICmp(pArgV[i], "/help"))

|| (0 == RTStrICmp(pArgV[i], "/?")))

{

ShowInfo("-- %s v%d.%d.%d.%d --\n"

"Command Line Parameters:\n\n"

"-extract | -x - Extract file contents to temporary directory\n"

"-silent | -s - Enables silent mode installation\n"

"-path | -p - Sets the path of the extraction directory\n"

"-help | /? - Print this help and exit\n"

"-msiparams <parameters> - Specifies extra parameters for the MSI installers\n"

"-logging | -l - Enables installer logging\n"

"-version | -v - Print version number and exit\n\n"

"Examples:\n"

"%s -msiparams INSTALLDIR=C:\\VBox\n"

"%s -extract -path C:\\VBox\n",

VBOX_STUB_TITLE, VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD, VBOX_SVN_REV,

pArgV[0], pArgV[0]);

bExit = TRUE;

}

else

{

if (i > 0)

{

ShowInfo("Unknown option \"%s\"!\n"

"Please refer to the command line help by specifying \"/?\"\n"

"to get more information.", pArgV[i]);

bExit = TRUE;

}

}

}

if (bExit)

return 0;

HRESULT hr = S_OK;

do /* break loop */

{

/* Get/create our temp path (only if not already set). */

if (szExtractPath[0] == '\0')

{

vrc = RTPathTemp(szExtractPath, sizeof(szExtractPath));

AssertMsgRCBreak(vrc, ("Could not retrieve temp directory!\n"));

vrc = RTPathAppend(szExtractPath, sizeof(szExtractPath), "VirtualBox");

AssertMsgRCBreak(vrc, ("Could not construct temp directory!\n"));

}

if (!RTDirExists(szExtractPath))

{

vrc = RTDirCreate(szExtractPath, 0700);

AssertMsgRCBreak(vrc, ("Could not create temp directory!\n"));

}

/* Get our executable path */

char szPathExe[_MAX_PATH];

vrc = RTPathExecDir(szPathExe, sizeof(szPathExe));

/** @todo error checking */

/* Read our manifest. */

PVBOXSTUBPKGHEADER pHeader = NULL;

DWORD cbHeader = 0;

vrc = ReadData(NULL, "MANIFEST", (LPVOID*)&pHeader, &cbHeader);

AssertMsgRCBreak(vrc, ("Manifest not found!\n"));

/* Extract files. */

for (BYTE k = 0; k < pHeader->byCntPkgs; k++)

{

PVBOXSTUBPKG pPackage = NULL;

DWORD cbPackage = 0;

char szHeaderName[_MAX_PATH] = {0};

hr = ::StringCchPrintf(szHeaderName, _MAX_PATH, "HDR_%02d", k);

vrc = ReadData(NULL, szHeaderName, (LPVOID*)&pPackage, &cbPackage);

AssertMsgRCBreak(vrc, ("Header not found!\n")); /** @todo include header name, how? */

if (PackageIsNeeded(pPackage) || fExtractOnly)

{

char *pszTempFile = NULL;

vrc = GetTempFileAlloc(szExtractPath, pPackage->szFileName, &pszTempFile);

AssertMsgRCBreak(vrc, ("Could not create name for temporary extracted file!\n"));

vrc = Extract(pPackage, pszTempFile);

AssertMsgRCBreak(vrc, ("Could not extract file!\n"));

RTStrFree(pszTempFile);

}

}

if (FALSE == fExtractOnly && !RT_FAILURE(vrc))

{

/*

char *pszPathCustomDir = RTPathJoinA(szPathExe, ".custom");

if (pszPathCustomDir && RTDirExists(pszPathCustomDir))

{

vrc = CopyDir(szExtractPath, pszPathCustomDir);

if (RT_FAILURE(vrc)) /* Don't fail if it's missing! */

vrc = VINF_SUCCESS;

RTStrFree(pszPathCustomDir);

}

/* Do actions on files. */

for (BYTE k = 0; k < pHeader->byCntPkgs; k++)

{

PVBOXSTUBPKG pPackage = NULL;

DWORD cbPackage = 0;

char szHeaderName[_MAX_PATH] = {0};

hr = StringCchPrintf(szHeaderName, _MAX_PATH, "HDR_%02d", k);

vrc = ReadData(NULL, szHeaderName, (LPVOID*)&pPackage, &cbPackage);

AssertMsgRCBreak(vrc, ("Package not found!\n"));

if (PackageIsNeeded(pPackage))

{

char *pszTempFile = NULL;

vrc = GetTempFileAlloc(szExtractPath, pPackage->szFileName, &pszTempFile);

AssertMsgRCBreak(vrc, ("Could not create name for temporary action file!\n"));

/* Handle MSI files. */

if (RTStrICmp(RTPathExt(pszTempFile), ".msi") == 0)

{

/* Set UI level. */

INSTALLUILEVEL UILevel = MsiSetInternalUI( fSilent

? INSTALLUILEVEL_NONE

: INSTALLUILEVEL_FULL,

NULL);

AssertMsgBreak(UILevel != INSTALLUILEVEL_NOCHANGE, ("Could not set installer UI level!\n"));

/* Enable logging? */

if (fEnableLogging)

{

char *pszLog = RTPathJoinA(szExtractPath, "VBoxInstallLog.txt");

AssertMsgRCBreak(vrc, ("Could not convert MSI log string to current codepage!\n"));

UINT uLogLevel = MsiEnableLog(INSTALLLOGMODE_VERBOSE,

pszLog, INSTALLLOGATTRIBUTES_FLUSHEACHLINE);

RTStrFree(pszLog);

AssertMsgBreak(uLogLevel == ERROR_SUCCESS, ("Could not set installer logging level!\n"));

}

UINT uStatus = ::MsiInstallProductA(pszTempFile, szMSIArgs);

if ( (uStatus != ERROR_SUCCESS)

&& (uStatus != ERROR_SUCCESS_REBOOT_REQUIRED)

&& (uStatus != ERROR_INSTALL_USEREXIT))

{

if (!fSilent)

{

switch (uStatus)

{

case ERROR_INSTALL_PACKAGE_VERSION:

ShowError("This installation package cannot be installed by the Windows Installer service.\n"

"You must install a Windows service pack that contains a newer version of the Windows Installer service.");

break;

case ERROR_INSTALL_PLATFORM_UNSUPPORTED:

ShowError("This installation package is not supported on this platform.\n");

break;

default:

/** @todo Use FormatMessage here! */

ShowError("Installation failed! ERROR: %u", uStatus);

break;

}

}

vrc = VERR_NO_CHANGE; /* No change done to the system. */

}

}

RTStrFree(pszTempFile);

} /* Package needed? */

} /* For all packages */

}

/* Clean up (only on success - prevent deleting the log). */

if ( !fExtractOnly

&& RT_SUCCESS(vrc))

{

for (int i=0; i<5; i++)

{

vrc = RTDirRemoveRecursive(szExtractPath, 0 /*fFlags*/);

if (RT_SUCCESS(vrc))

break;

RTThreadSleep(3000 /* Wait 3 seconds.*/);

}

}

} while (0);

if (RT_SUCCESS(vrc))

{

if ( fExtractOnly

&& !fSilent)

{

ShowInfo("Files were extracted to: %s", szExtractPath);

}

/** @todo Add more post installation stuff here if required. */

}

/* Release instance mutex. */

if (hMutexAppRunning != NULL)

{

CloseHandle(hMutexAppRunning);

hMutexAppRunning = NULL;

}

/* Set final exit (return) code (error level). */

if (RT_FAILURE(vrc))

{

switch(vrc)

{

case VERR_NO_CHANGE:

default:

vrc = 1;

}

}

else /* Always set to (VINF_SUCCESS), even if we got something else (like a VWRN etc). */

vrc = VINF_SUCCESS;

return vrc;

}