19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#ifndef VBOX_ONLY_DOCS

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <VBox/com/com.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/com/string.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/com/Guid.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/com/array.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/com/ErrorInfo.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/com/errorprint.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <VBox/com/EventQueue.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <VBox/com/VirtualBox.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#endif /* !VBOX_ONLY_DOCS */

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/asm.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/buildconfig.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/cidr.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/ctype.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/dir.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/env.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <VBox/err.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/file.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/initterm.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/param.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <iprt/path.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <iprt/stream.h>

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync#include <iprt/string.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/stdarg.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/thread.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/uuid.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/getopt.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <iprt/ctype.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <VBox/version.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include <VBox/log.h>

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync#include "VBoxManage.h"

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync

9040f019271f91b98e1320c0a8c38a42636e3979vboxsyncusing namespace com;

9040f019271f91b98e1320c0a8c38a42636e3979vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsyncint handleRegisterVM(HandlerArg *a)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync{

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync HRESULT rc;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (a->argc != 1)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters");

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

cc5db764b0331d17575b3f384d29e1c74970e62fvboxsync ComPtr<IMachine> machine;

99be02f9e15a3ca61b6a7c207cc7eb68dbd04817vboxsync /** @todo Ugly hack to get both the API interpretation of relative paths

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(),

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync machine.asOutParam());

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (rc == VBOX_E_FILE_ERROR)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync char szVMFileAbs[RTPATH_MAX] = "";

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync int vrc = RTPathAbs(a->argv[0], szVMFileAbs, sizeof(szVMFileAbs));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (RT_FAILURE(vrc))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTMsgError("Cannot convert filename \"%s\" to absolute path", a->argv[0]);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return 1;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs).raw(),

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync machine.asOutParam()));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if (FAILED(rc))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]).raw(),

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync machine.asOutParam()));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (SUCCEEDED(rc))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync ASSERT(machine);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(a->virtualBox, RegisterMachine(machine));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return SUCCEEDED(rc) ? 0 : 1;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync}

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsyncstatic const RTGETOPTDEF g_aUnregisterVMOptions[] =

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync{

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync { "--delete", 'd', RTGETOPT_REQ_NOTHING },

6c90795355c6e59ba82e8e5a58e10d686a6d6e65vboxsync { "-delete", 'd', RTGETOPT_REQ_NOTHING }, // deprecated

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync};

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsyncint handleUnregisterVM(HandlerArg *a)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync{

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync HRESULT rc;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync const char *VMName = NULL;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync bool fDelete = false;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync int c;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTGETOPTUNION ValueUnion;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTGETOPTSTATE GetState;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync // start at 0 because main() has hacked both the argc and argv given to us

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTGetOptInit(&GetState, a->argc, a->argv, g_aUnregisterVMOptions, RT_ELEMENTS(g_aUnregisterVMOptions),

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync while ((c = RTGetOpt(&GetState, &ValueUnion)))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync switch (c)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync case 'd': // --delete

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync fDelete = true;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync break;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync case VINF_GETOPT_NOT_OPTION:

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (!VMName)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync VMName = ValueUnion.psz;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "Invalid parameter '%s'", ValueUnion.psz);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync break;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync default:

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (c > 0)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (RT_C_IS_PRINT(c))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "Invalid option -%c", c);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "Invalid option case %i", c);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if (c == VERR_GETOPT_UNKNOWN_OPTION)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "unknown option: %s\n", ValueUnion.psz);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if (ValueUnion.pDef)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "error: %Rrs", c);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync /* check for required options */

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (!VMName)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorSyntax(USAGE_UNREGISTERVM, "VM name required");

a0a9f39e8864357c2e1e61106958411240f5bf6bvboxsync

a0a9f39e8864357c2e1e61106958411240f5bf6bvboxsync ComPtr<IMachine> machine;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync /* assume it's a UUID */

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (FAILED(rc) || !machine)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync /* must be a name */

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync machine.asOutParam()));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (machine)

7eaaa8a4480370b82ef3735994f986f338fb4df2vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync SafeIfaceArray<IMedium> aMedia;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CleanupMode_T cleanupMode = CleanupMode_DetachAllReturnNone;

479124979f37167f8ce75bf59090903d30e1ced3vboxsync if (fDelete)

479124979f37167f8ce75bf59090903d30e1ced3vboxsync cleanupMode = CleanupMode_DetachAllReturnHardDisksOnly;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(machine, Unregister(cleanupMode,

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync ComSafeArrayAsOutParam(aMedia)));

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (SUCCEEDED(rc))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (fDelete)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync ComPtr<IProgress> pProgress;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync CHECK_ERROR(machine, Delete(ComSafeArrayAsInParam(aMedia), pProgress.asOutParam()));

71e61358090b8d7bad611a6d38786ebd63ed04e1vboxsync CHECK_ERROR(pProgress, WaitForCompletion(-1));

71e61358090b8d7bad611a6d38786ebd63ed04e1vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return SUCCEEDED(rc) ? 0 : 1;

88e9d91abf9293ecc1c70e0bf40e42f1c3a0bdcevboxsync}

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsyncint handleCreateVM(HandlerArg *a)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync{

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync HRESULT rc;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync Bstr baseFolder;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync Bstr name;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync Bstr osTypeId;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTUUID id;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync bool fRegister = false;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync RTUuidClear(&id);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync for (int i = 0; i < a->argc; i++)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if ( !strcmp(a->argv[i], "--basefolder")

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync || !strcmp(a->argv[i], "-basefolder"))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (a->argc <= i + 1)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorArgument("Missing argument to '%s'", a->argv[i]);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync i++;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync baseFolder = a->argv[i];

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if ( !strcmp(a->argv[i], "--name")

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync || !strcmp(a->argv[i], "-name"))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (a->argc <= i + 1)

479124979f37167f8ce75bf59090903d30e1ced3vboxsync return errorArgument("Missing argument to '%s'", a->argv[i]);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync i++;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync name = a->argv[i];

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if ( !strcmp(a->argv[i], "--ostype")

6831f283dbc5c27bde8a8f8bea179b84a5741697vboxsync || !strcmp(a->argv[i], "-ostype"))

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync {

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync if (a->argc <= i + 1)

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync return errorArgument("Missing argument to '%s'", a->argv[i]);

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync i++;

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync osTypeId = a->argv[i];

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync }

19a258565a4d24e5a0af62f626943ac9b898d957vboxsync else if ( !strcmp(a->argv[i], "--uuid")

479124979f37167f8ce75bf59090903d30e1ced3vboxsync || !strcmp(a->argv[i], "-uuid"))

{

if (a->argc <= i + 1)

return errorArgument("Missing argument to '%s'", a->argv[i]);

i++;

if (RT_FAILURE(RTUuidFromStr(&id, a->argv[i])))

return errorArgument("Invalid UUID format %s\n", a->argv[i]);

}

else if ( !strcmp(a->argv[i], "--register")

|| !strcmp(a->argv[i], "-register"))

{

fRegister = true;

}

else

return errorSyntax(USAGE_CREATEVM, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str());

}

/* check for required options */

if (name.isEmpty())

return errorSyntax(USAGE_CREATEVM, "Parameter --name is required");

do

{

ComPtr<IMachine> machine;

CHECK_ERROR_BREAK(a->virtualBox,

CreateMachine(name.raw(),

osTypeId.raw(),

baseFolder.raw(),

Guid(id).toUtf16().raw(),

FALSE,

machine.asOutParam()));

CHECK_ERROR_BREAK(machine, SaveSettings());

if (fRegister)

{

CHECK_ERROR_BREAK(a->virtualBox, RegisterMachine(machine));

}

Bstr uuid;

CHECK_ERROR_BREAK(machine, COMGETTER(Id)(uuid.asOutParam()));

Bstr settingsFile;

CHECK_ERROR_BREAK(machine, COMGETTER(SettingsFilePath)(settingsFile.asOutParam()));

RTPrintf("Virtual machine '%ls' is created%s.\n"

"UUID: %s\n"

"Settings file: '%ls'\n",

name.raw(), fRegister ? " and registered" : "",

Utf8Str(uuid).c_str(), settingsFile.raw());

}

while (0);

return SUCCEEDED(rc) ? 0 : 1;

}

int handleStartVM(HandlerArg *a)

{

HRESULT rc;

const char *VMName = NULL;

Bstr sessionType = "gui";

static const RTGETOPTDEF s_aStartVMOptions[] =

{

{ "--type", 't', RTGETOPT_REQ_STRING },

{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated

};

int c;

RTGETOPTUNION ValueUnion;

RTGETOPTSTATE GetState;

// start at 0 because main() has hacked both the argc and argv given to us

RTGetOptInit(&GetState, a->argc, a->argv, s_aStartVMOptions, RT_ELEMENTS(s_aStartVMOptions),

0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);

while ((c = RTGetOpt(&GetState, &ValueUnion)))

{

switch (c)

{

case 't': // --type

if (!RTStrICmp(ValueUnion.psz, "gui"))

{

sessionType = "gui";

}

#ifdef VBOX_WITH_VBOXSDL

else if (!RTStrICmp(ValueUnion.psz, "sdl"))

{

sessionType = "sdl";

}

#endif

#ifdef VBOX_WITH_VRDP

else if (!RTStrICmp(ValueUnion.psz, "vrdp"))

{

sessionType = "vrdp";

}

#endif

#ifdef VBOX_WITH_HEADLESS

else if (!RTStrICmp(ValueUnion.psz, "capture"))

{

sessionType = "capture";

}

else if (!RTStrICmp(ValueUnion.psz, "headless"))

{

sessionType = "headless";

}

#endif

else

return errorArgument("Invalid session type '%s'", ValueUnion.psz);

break;

case VINF_GETOPT_NOT_OPTION:

if (!VMName)

VMName = ValueUnion.psz;

else

return errorSyntax(USAGE_STARTVM, "Invalid parameter '%s'", ValueUnion.psz);

break;

default:

if (c > 0)

{

if (RT_C_IS_PRINT(c))

return errorSyntax(USAGE_STARTVM, "Invalid option -%c", c);

else

return errorSyntax(USAGE_STARTVM, "Invalid option case %i", c);

}

else if (c == VERR_GETOPT_UNKNOWN_OPTION)

return errorSyntax(USAGE_STARTVM, "unknown option: %s\n", ValueUnion.psz);

else if (ValueUnion.pDef)

return errorSyntax(USAGE_STARTVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);

else

return errorSyntax(USAGE_STARTVM, "error: %Rrs", c);

}

}

/* check for required options */

if (!VMName)

return errorSyntax(USAGE_STARTVM, "VM name required");

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(VMName).raw(), machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMName).raw(),

machine.asOutParam()));

}

if (machine)

{

Bstr env;

#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)

/* make sure the VM process will start on the same display as VBoxManage */

Utf8Str str;

const char *pszDisplay = RTEnvGet("DISPLAY");

if (pszDisplay)

str = Utf8StrFmt("DISPLAY=%s\n", pszDisplay);

const char *pszXAuth = RTEnvGet("XAUTHORITY");

if (pszXAuth)

str.append(Utf8StrFmt("XAUTHORITY=%s\n", pszXAuth));

env = str;

#endif

ComPtr<IProgress> progress;

CHECK_ERROR_RET(machine, LaunchVMProcess(a->session, sessionType.raw(),

env.raw(), progress.asOutParam()), rc);

RTPrintf("Waiting for the VM to power on...\n");

CHECK_ERROR_RET(progress, WaitForCompletion(-1), 1);

BOOL completed;

CHECK_ERROR_RET(progress, COMGETTER(Completed)(&completed), rc);

ASSERT(completed);

LONG iRc;

CHECK_ERROR_RET(progress, COMGETTER(ResultCode)(&iRc), rc);

if (FAILED(iRc))

{

ComPtr<IVirtualBoxErrorInfo> errorInfo;

CHECK_ERROR_RET(progress, COMGETTER(ErrorInfo)(errorInfo.asOutParam()), 1);

ErrorInfo info(errorInfo, COM_IIDOF(IVirtualBoxErrorInfo));

com::GluePrintErrorInfo(info);

}

else

{

RTPrintf("VM has been successfully started.\n");

}

}

/* it's important to always close sessions */

a->session->UnlockMachine();

return SUCCEEDED(rc) ? 0 : 1;

}

int handleDiscardState(HandlerArg *a)

{

HRESULT rc;

if (a->argc != 1)

return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters");

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam()));

}

if (machine)

{

do

{

/* we have to open a session for this task */

CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write));

do

{

ComPtr<IConsole> console;

CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));

CHECK_ERROR_BREAK(console, DiscardSavedState(true /* fDeleteFile */));

} while (0);

CHECK_ERROR_BREAK(a->session, UnlockMachine());

} while (0);

}

return SUCCEEDED(rc) ? 0 : 1;

}

int handleAdoptState(HandlerArg *a)

{

HRESULT rc;

if (a->argc != 2)

return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters");

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam()));

}

if (machine)

{

do

{

/* we have to open a session for this task */

CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write));

do

{

ComPtr<IConsole> console;

CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam()));

CHECK_ERROR_BREAK(console, AdoptSavedState(Bstr(a->argv[1]).raw()));

} while (0);

CHECK_ERROR_BREAK(a->session, UnlockMachine());

} while (0);

}

return SUCCEEDED(rc) ? 0 : 1;

}

int handleGetExtraData(HandlerArg *a)

{

HRESULT rc = S_OK;

if (a->argc != 2)

return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");

/* global data? */

if (!strcmp(a->argv[0], "global"))

{

/* enumeration? */

if (!strcmp(a->argv[1], "enumerate"))

{

SafeArray<BSTR> aKeys;

CHECK_ERROR(a->virtualBox, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));

for (size_t i = 0;

i < aKeys.size();

++i)

{

Bstr bstrKey(aKeys[i]);

Bstr bstrValue;

CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey.raw(),

bstrValue.asOutParam()));

RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());

}

}

else

{

Bstr value;

CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]).raw(),

value.asOutParam()));

if (!value.isEmpty())

RTPrintf("Value: %lS\n", value.raw());

else

RTPrintf("No value set!\n");

}

}

else

{

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam()));

}

if (machine)

{

/* enumeration? */

if (!strcmp(a->argv[1], "enumerate"))

{

SafeArray<BSTR> aKeys;

CHECK_ERROR(machine, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));

for (size_t i = 0;

i < aKeys.size();

++i)

{

Bstr bstrKey(aKeys[i]);

Bstr bstrValue;

CHECK_ERROR(machine, GetExtraData(bstrKey.raw(),

bstrValue.asOutParam()));

RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());

}

}

else

{

Bstr value;

CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]).raw(),

value.asOutParam()));

if (!value.isEmpty())

RTPrintf("Value: %lS\n", value.raw());

else

RTPrintf("No value set!\n");

}

}

}

return SUCCEEDED(rc) ? 0 : 1;

}

int handleSetExtraData(HandlerArg *a)

{

HRESULT rc = S_OK;

if (a->argc < 2)

return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters");

/* global data? */

if (!strcmp(a->argv[0], "global"))

{

/** @todo passing NULL is deprecated */

if (a->argc < 3)

CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),

NULL));

else if (a->argc == 3)

CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),

Bstr(a->argv[2]).raw()));

else

return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");

}

else

{

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam()));

}

if (machine)

{

/** @todo passing NULL is deprecated */

if (a->argc < 3)

CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]).raw(),

NULL));

else if (a->argc == 3)

CHECK_ERROR(machine, SetExtraData(Bstr(a->argv[1]).raw(),

Bstr(a->argv[2]).raw()));

else

return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");

}

}

return SUCCEEDED(rc) ? 0 : 1;

}

int handleSetProperty(HandlerArg *a)

{

HRESULT rc;

/* there must be two arguments: property name and value */

if (a->argc != 2)

return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters");

ComPtr<ISystemProperties> systemProperties;

a->virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());

if (!strcmp(a->argv[0], "hdfolder"))

{

/* reset to default? */

if (!strcmp(a->argv[1], "default"))

CHECK_ERROR(systemProperties, COMSETTER(DefaultHardDiskFolder)(NULL));

else

CHECK_ERROR(systemProperties, COMSETTER(DefaultHardDiskFolder)(Bstr(a->argv[1]).raw()));

}

else if (!strcmp(a->argv[0], "machinefolder"))

{

/* reset to default? */

if (!strcmp(a->argv[1], "default"))

CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(NULL));

else

CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(a->argv[1]).raw()));

}

else if (!strcmp(a->argv[0], "vrdpauthlibrary"))

{

/* reset to default? */

if (!strcmp(a->argv[1], "default"))

CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(NULL));

else

CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(Bstr(a->argv[1]).raw()));

}

else if (!strcmp(a->argv[0], "websrvauthlibrary"))

{

/* reset to default? */

if (!strcmp(a->argv[1], "default"))

CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(NULL));

else

CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(a->argv[1]).raw()));

}

else if (!strcmp(a->argv[0], "loghistorycount"))

{

uint32_t uVal;

int vrc;

vrc = RTStrToUInt32Ex(a->argv[1], NULL, 0, &uVal);

if (vrc != VINF_SUCCESS)

return errorArgument("Error parsing Log history count '%s'", a->argv[1]);

CHECK_ERROR(systemProperties, COMSETTER(LogHistoryCount)(uVal));

}

else

return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", a->argv[0]);

return SUCCEEDED(rc) ? 0 : 1;

}

int handleSharedFolder(HandlerArg *a)

{

HRESULT rc;

/* we need at least a command and target */

if (a->argc < 2)

return errorSyntax(USAGE_SHAREDFOLDER, "Not enough parameters");

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = a->virtualBox->GetMachine(Bstr(a->argv[1]).raw(),

machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[1]).raw(),

machine.asOutParam()));

}

if (!machine)

return 1;

if (!strcmp(a->argv[0], "add"))

{

/* we need at least four more parameters */

if (a->argc < 5)

return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Not enough parameters");

char *name = NULL;

char *hostpath = NULL;

bool fTransient = false;

bool fWritable = true;

bool fAutoMount = false;

for (int i = 2; i < a->argc; i++)

{

if ( !strcmp(a->argv[i], "--name")

|| !strcmp(a->argv[i], "-name"))

{

if (a->argc <= i + 1 || !*a->argv[i+1])

return errorArgument("Missing argument to '%s'", a->argv[i]);

i++;

name = a->argv[i];

}

else if ( !strcmp(a->argv[i], "--hostpath")

|| !strcmp(a->argv[i], "-hostpath"))

{

if (a->argc <= i + 1 || !*a->argv[i+1])

return errorArgument("Missing argument to '%s'", a->argv[i]);

i++;

hostpath = a->argv[i];

}

else if ( !strcmp(a->argv[i], "--readonly")

|| !strcmp(a->argv[i], "-readonly"))

{

fWritable = false;

}

else if ( !strcmp(a->argv[i], "--transient")

|| !strcmp(a->argv[i], "-transient"))

{

fTransient = true;

}

else if ( !strcmp(a->argv[i], "--automount")

|| !strcmp(a->argv[i], "-automount"))

{

fAutoMount = true;

}

else

return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str());

}

if (NULL != strstr(name, " "))

return errorSyntax(USAGE_SHAREDFOLDER_ADD, "No spaces allowed in parameter '-name'!");

/* required arguments */

if (!name || !hostpath)

{

return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Parameters --name and --hostpath are required");

}

if (fTransient)

{

ComPtr <IConsole> console;

/* open an existing session for the VM */

CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), 1);

/* get the session machine */

CHECK_ERROR_RET(a->session, COMGETTER(Machine)(machine.asOutParam()), 1);

/* get the session console */

CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), 1);

CHECK_ERROR(console, CreateSharedFolder(Bstr(name).raw(),

Bstr(hostpath).raw(),

fWritable, fAutoMount));

if (console)

a->session->UnlockMachine();

}

else

{

/* open a session for the VM */

SessionType_T st;

CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), 1);

/* get the mutable session machine */

a->session->COMGETTER(Machine)(machine.asOutParam());

CHECK_ERROR(machine, CreateSharedFolder(Bstr(name).raw(),

Bstr(hostpath).raw(),

fWritable, fAutoMount));

if (SUCCEEDED(rc))

CHECK_ERROR(machine, SaveSettings());

a->session->UnlockMachine();

}

}

else if (!strcmp(a->argv[0], "remove"))

{

/* we need at least two more parameters */

if (a->argc < 3)

return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Not enough parameters");

char *name = NULL;

bool fTransient = false;

for (int i = 2; i < a->argc; i++)

{

if ( !strcmp(a->argv[i], "--name")

|| !strcmp(a->argv[i], "-name"))

{

if (a->argc <= i + 1 || !*a->argv[i+1])

return errorArgument("Missing argument to '%s'", a->argv[i]);

i++;

name = a->argv[i];

}

else if ( !strcmp(a->argv[i], "--transient")

|| !strcmp(a->argv[i], "-transient"))

{

fTransient = true;

}

else

return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str());

}

/* required arguments */

if (!name)

return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Parameter --name is required");

if (fTransient)

{

ComPtr <IConsole> console;

/* open an existing session for the VM */

CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), 1);

/* get the session machine */

CHECK_ERROR_RET(a->session, COMGETTER(Machine)(machine.asOutParam()), 1);

/* get the session console */

CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), 1);

CHECK_ERROR(console, RemoveSharedFolder(Bstr(name).raw()));

if (console)

a->session->UnlockMachine();

}

else

{

/* open a session for the VM */

CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), 1);

/* get the mutable session machine */

a->session->COMGETTER(Machine)(machine.asOutParam());

CHECK_ERROR(machine, RemoveSharedFolder(Bstr(name).raw()));

/* commit and close the session */

CHECK_ERROR(machine, SaveSettings());

a->session->UnlockMachine();

}

}

else

return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str());

return 0;

}

int handleVMStatistics(HandlerArg *a)

{

HRESULT rc;

/* at least one option: the UUID or name of the VM */

if (a->argc < 1)

return errorSyntax(USAGE_VM_STATISTICS, "Incorrect number of parameters");

/* try to find the given machine */

ComPtr<IMachine> machine;

Bstr uuid(a->argv[0]);

if (!Guid(a->argv[0]).isEmpty())

CHECK_ERROR(a->virtualBox, GetMachine(uuid.raw(),

machine.asOutParam()));

else

{

CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),

machine.asOutParam()));

if (SUCCEEDED(rc))

machine->COMGETTER(Id)(uuid.asOutParam());

}

if (FAILED(rc))

return 1;

/* parse arguments. */

bool fReset = false;

bool fWithDescriptions = false;

const char *pszPattern = NULL; /* all */

for (int i = 1; i < a->argc; i++)

{

if ( !strcmp(a->argv[i], "--pattern")

|| !strcmp(a->argv[i], "-pattern"))

{

if (pszPattern)

return errorSyntax(USAGE_VM_STATISTICS, "Multiple --patterns options is not permitted");

if (i + 1 >= a->argc)

return errorArgument("Missing argument to '%s'", a->argv[i]);

pszPattern = a->argv[++i];

}

else if ( !strcmp(a->argv[i], "--descriptions")

|| !strcmp(a->argv[i], "-descriptions"))

fWithDescriptions = true;

/* add: --file <filename> and --formatted */

else if ( !strcmp(a->argv[i], "--reset")

|| !strcmp(a->argv[i], "-reset"))

fReset = true;

else

return errorSyntax(USAGE_VM_STATISTICS, "Unknown option '%s'", a->argv[i]);

}

if (fReset && fWithDescriptions)

return errorSyntax(USAGE_VM_STATISTICS, "The --reset and --descriptions options does not mix");

/* open an existing session for the VM. */

CHECK_ERROR(machine, LockMachine(a->session, LockType_Shared));

if (SUCCEEDED(rc))

{

/* get the session console. */

ComPtr <IConsole> console;

CHECK_ERROR(a->session, COMGETTER(Console)(console.asOutParam()));

if (SUCCEEDED(rc))

{

/* get the machine debugger. */

ComPtr <IMachineDebugger> debugger;

CHECK_ERROR(console, COMGETTER(Debugger)(debugger.asOutParam()));

if (SUCCEEDED(rc))

{

if (fReset)

CHECK_ERROR(debugger, ResetStats(Bstr(pszPattern).raw()));

else

{

Bstr stats;

CHECK_ERROR(debugger, GetStats(Bstr(pszPattern).raw(),

fWithDescriptions,

stats.asOutParam()));

if (SUCCEEDED(rc))

{

/* if (fFormatted)

RTPrintf("%ls\n", stats.raw());

}

}

}

a->session->UnlockMachine();

}

}

return SUCCEEDED(rc) ? 0 : 1;

}