/* $Id: VBoxManage.cpp 91617 2021-10-07 11:17:43Z vboxsync $ */ /** @file * VBoxManage - VirtualBox's command-line interface. */ /* * Copyright (C) 2006-2020 Oracle Corporation * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; * you can redistribute it and/or modify it under the terms of the GNU * General Public License (GPL) as published by the Free Software * Foundation, in version 2 as it comes in the "COPYING" file of the * VirtualBox OSE distribution. VirtualBox OSE is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #ifndef VBOX_ONLY_DOCS # include # include # include # include # include # include # include # include #endif /* !VBOX_ONLY_DOCS */ #include #include #include #include #include #include #include #include #include #include #include #include "VBoxManage.h" /********************************************************************************************************************************* * Defined Constants And Macros * *********************************************************************************************************************************/ /** The command doesn't need the COM stuff. */ #define VBMG_CMD_F_NO_COM RT_BIT_32(0) #define VBMG_CMD_TODO HELP_CMD_VBOXMANAGE_INVALID /********************************************************************************************************************************* * Structures and Typedefs * *********************************************************************************************************************************/ #ifndef VBOX_ONLY_DOCS /** * VBoxManage command descriptor. */ typedef struct VBMGCMD { /** The command. */ const char *pszCommand; /** The help category. */ USAGECATEGORY enmHelpCat; /** The new help command. */ enum HELP_CMD_VBOXMANAGE enmCmdHelp; /** The handler. */ RTEXITCODE (*pfnHandler)(HandlerArg *pArg); /** VBMG_CMD_F_XXX, */ uint32_t fFlags; } VBMGCMD; /** Pointer to a const VBoxManage command descriptor. */ typedef VBMGCMD const *PCVBMGCMD; #endif /********************************************************************************************************************************* * Global Variables * *********************************************************************************************************************************/ /*extern*/ bool g_fDetailedProgress = false; #ifndef VBOX_ONLY_DOCS /** Set by the signal handler. */ static volatile bool g_fCanceled = false; /** * All registered command handlers */ static const VBMGCMD g_aCommands[] = { { "internalcommands", USAGE_INVALID, VBMG_CMD_TODO, handleInternalCommands, 0 }, { "list", USAGE_S_NEWCMD, HELP_CMD_LIST, handleList, 0 }, { "showvminfo", USAGE_S_NEWCMD, HELP_CMD_SHOWVMINFO, handleShowVMInfo, 0 }, { "registervm", USAGE_S_NEWCMD, HELP_CMD_REGISTERVM, handleRegisterVM, 0 }, { "unregistervm", USAGE_S_NEWCMD, HELP_CMD_UNREGISTERVM, handleUnregisterVM, 0 }, { "clonevm", USAGE_S_NEWCMD, HELP_CMD_CLONEVM, handleCloneVM, 0 }, { "movevm", USAGE_S_NEWCMD, HELP_CMD_MOVEVM, handleMoveVM, 0 }, { "mediumproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, { "hdproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, /* backward compatibility */ { "createmedium", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, { "createhd", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */ { "createvdi", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */ { "modifymedium", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, { "modifyhd", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */ { "modifyvdi", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */ { "clonemedium", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, { "clonehd", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */ { "clonevdi", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */ { "encryptmedium", USAGE_ENCRYPTMEDIUM, VBMG_CMD_TODO, handleEncryptMedium, 0 }, { "checkmediumpwd", USAGE_MEDIUMENCCHKPWD, VBMG_CMD_TODO, handleCheckMediumPassword, 0 }, { "createvm", USAGE_S_NEWCMD, HELP_CMD_CREATEVM, handleCreateVM, 0 }, { "modifyvm", USAGE_S_NEWCMD, HELP_CMD_MODIFYVM, handleModifyVM, 0 }, { "startvm", USAGE_STARTVM, VBMG_CMD_TODO, handleStartVM, 0 }, { "controlvm", USAGE_CONTROLVM, VBMG_CMD_TODO, handleControlVM, 0 }, { "unattended", USAGE_S_NEWCMD, HELP_CMD_UNATTENDED, handleUnattended, 0 }, { "discardstate", USAGE_DISCARDSTATE, VBMG_CMD_TODO, handleDiscardState, 0 }, { "adoptstate", USAGE_ADOPTSTATE, VBMG_CMD_TODO, handleAdoptState, 0 }, { "snapshot", USAGE_S_NEWCMD, HELP_CMD_SNAPSHOT, handleSnapshot, 0 }, { "closemedium", USAGE_CLOSEMEDIUM, VBMG_CMD_TODO, handleCloseMedium, 0 }, { "storageattach", USAGE_STORAGEATTACH, VBMG_CMD_TODO, handleStorageAttach, 0 }, { "storagectl", USAGE_STORAGECONTROLLER,VBMG_CMD_TODO, handleStorageController, 0 }, { "showmediuminfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, { "showhdinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */ { "showvdiinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */ { "mediumio", USAGE_S_NEWCMD, HELP_CMD_MEDIUMIO, handleMediumIO, 0 }, { "getextradata", USAGE_GETEXTRADATA, VBMG_CMD_TODO, handleGetExtraData, 0 }, { "setextradata", USAGE_SETEXTRADATA, VBMG_CMD_TODO, handleSetExtraData, 0 }, { "setproperty", USAGE_SETPROPERTY, VBMG_CMD_TODO, handleSetProperty, 0 }, { "usbfilter", USAGE_USBFILTER, VBMG_CMD_TODO, handleUSBFilter, 0 }, { "sharedfolder", USAGE_S_NEWCMD, HELP_CMD_SHAREDFOLDER, handleSharedFolder, 0 }, #ifdef VBOX_WITH_GUEST_PROPS { "guestproperty", USAGE_GUESTPROPERTY, VBMG_CMD_TODO, handleGuestProperty, 0 }, #endif #ifdef VBOX_WITH_GUEST_CONTROL { "guestcontrol", USAGE_GUESTCONTROL, VBMG_CMD_TODO, handleGuestControl, 0 }, #endif { "metrics", USAGE_METRICS, VBMG_CMD_TODO, handleMetrics, 0 }, { "import", USAGE_S_NEWCMD, HELP_CMD_IMPORT, handleImportAppliance, 0 }, { "export", USAGE_S_NEWCMD, HELP_CMD_EXPORT, handleExportAppliance, 0 }, { "signova", USAGE_S_NEWCMD, HELP_CMD_SIGNOVA, handleSignAppliance, VBMG_CMD_F_NO_COM }, #ifdef VBOX_WITH_NETFLT { "hostonlyif", USAGE_HOSTONLYIFS, VBMG_CMD_TODO, handleHostonlyIf, 0 }, #endif #ifdef VBOX_WITH_VMNET { "hostonlynet", USAGE_S_NEWCMD, HELP_CMD_HOSTONLYNET, handleHostonlyNet, 0 }, #endif { "dhcpserver", USAGE_S_NEWCMD, HELP_CMD_DHCPSERVER, handleDHCPServer, 0 }, #ifdef VBOX_WITH_NAT_SERVICE { "natnetwork", USAGE_NATNETWORK, VBMG_CMD_TODO, handleNATNetwork, 0 }, #endif { "extpack", USAGE_S_NEWCMD, HELP_CMD_EXTPACK, handleExtPack, 0 }, { "bandwidthctl", USAGE_BANDWIDTHCONTROL, VBMG_CMD_TODO, handleBandwidthControl, 0 }, { "debugvm", USAGE_S_NEWCMD, HELP_CMD_DEBUGVM, handleDebugVM, 0 }, { "convertfromraw", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM }, { "convertdd", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM }, { "usbdevsource", USAGE_USBDEVSOURCE, VBMG_CMD_TODO, handleUSBDevSource, 0 }, { "cloudprofile", USAGE_S_NEWCMD, HELP_CMD_CLOUDPROFILE, handleCloudProfile, 0 }, { "cloud", USAGE_S_NEWCMD, HELP_CMD_CLOUD, handleCloud, 0 }, { "updatecheck", USAGE_S_NEWCMD, HELP_CMD_UPDATECHECK, handleUpdateCheck, 0 }, { "modifynvram", USAGE_S_NEWCMD, HELP_CMD_MODIFYNVRAM, handleModifyNvram, 0 }, }; /** * Looks up a command by name. * * @returns Pointer to the command structure. * @param pszCommand Name of the command. */ static PCVBMGCMD lookupCommand(const char *pszCommand) { if (pszCommand) for (uint32_t i = 0; i < RT_ELEMENTS(g_aCommands); i++) if (!strcmp(g_aCommands[i].pszCommand, pszCommand)) return &g_aCommands[i]; return NULL; } /** * Signal handler that sets g_fCanceled. * * This can be executed on any thread in the process, on Windows it may even be * a thread dedicated to delivering this signal. Do not doing anything * unnecessary here. */ static void showProgressSignalHandler(int iSignal) RT_NOTHROW_DEF { NOREF(iSignal); ASMAtomicWriteBool(&g_fCanceled, true); } /** * Print out progress on the console. * * This runs the main event queue every now and then to prevent piling up * unhandled things (which doesn't cause real problems, just makes things * react a little slower than in the ideal case). */ HRESULT showProgress(ComPtr progress, unsigned int fFlags) { using namespace com; HRESULT hrc; AssertReturn(progress.isNotNull(), E_FAIL); /* grandfather the old callers */ if (g_fDetailedProgress) fFlags = SHOW_PROGRESS_DETAILS; const bool fDetailed = RT_BOOL(fFlags & SHOW_PROGRESS_DETAILS); const bool fQuiet = !RT_BOOL(fFlags & (SHOW_PROGRESS | SHOW_PROGRESS_DETAILS)); BOOL fCompleted = FALSE; ULONG ulCurrentPercent = 0; ULONG ulLastPercent = 0; ULONG ulLastOperationPercent = (ULONG)-1; ULONG ulLastOperation = (ULONG)-1; Bstr bstrOperationDescription; NativeEventQueue::getMainEventQueue()->processEventQueue(0); ULONG cOperations = 1; hrc = progress->COMGETTER(OperationCount)(&cOperations); if (FAILED(hrc)) { RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc); RTStrmFlush(g_pStdErr); return hrc; } /* * Note: Outputting the progress info to stderr (g_pStdErr) is intentional * to not get intermixed with other (raw) stdout data which might get * written in the meanwhile. */ if (fFlags & SHOW_PROGRESS_DESC) { com::Bstr bstrDescription; hrc = progress->COMGETTER(Description(bstrDescription.asOutParam())); if (FAILED(hrc)) { RTStrmPrintf(g_pStdErr, "Failed to get progress description: %Rhrc\n", hrc); return hrc; } const char *pcszDescSep; if (fDetailed) /* multiline output */ pcszDescSep = "\n"; else /* continues on the same line */ pcszDescSep = ": "; RTStrmPrintf(g_pStdErr, "%ls%s", bstrDescription.raw(), pcszDescSep); RTStrmFlush(g_pStdErr); } if (!fQuiet && !fDetailed) { RTStrmPrintf(g_pStdErr, "0%%..."); RTStrmFlush(g_pStdErr); } /* setup signal handling if cancelable */ bool fCanceledAlready = false; BOOL fCancelable; hrc = progress->COMGETTER(Cancelable)(&fCancelable); if (FAILED(hrc)) fCancelable = FALSE; if (fCancelable) { signal(SIGINT, showProgressSignalHandler); signal(SIGTERM, showProgressSignalHandler); #ifdef SIGBREAK signal(SIGBREAK, showProgressSignalHandler); #endif } hrc = progress->COMGETTER(Completed(&fCompleted)); while (SUCCEEDED(hrc)) { progress->COMGETTER(Percent(&ulCurrentPercent)); if (fDetailed) { ULONG ulOperation = 1; hrc = progress->COMGETTER(Operation)(&ulOperation); if (FAILED(hrc)) break; ULONG ulCurrentOperationPercent = 0; hrc = progress->COMGETTER(OperationPercent(&ulCurrentOperationPercent)); if (FAILED(hrc)) break; if (ulLastOperation != ulOperation) { hrc = progress->COMGETTER(OperationDescription(bstrOperationDescription.asOutParam())); if (FAILED(hrc)) break; ulLastPercent = (ULONG)-1; // force print ulLastOperation = ulOperation; } if ( ulCurrentPercent != ulLastPercent || ulCurrentOperationPercent != ulLastOperationPercent ) { LONG lSecsRem = 0; progress->COMGETTER(TimeRemaining)(&lSecsRem); RTStrmPrintf(g_pStdErr, "(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n", ulOperation + 1, cOperations, bstrOperationDescription.raw(), ulCurrentOperationPercent, ulCurrentPercent, lSecsRem); ulLastPercent = ulCurrentPercent; ulLastOperationPercent = ulCurrentOperationPercent; } } else if (!fQuiet) { /* did we cross a 10% mark? */ if (ulCurrentPercent / 10 > ulLastPercent / 10) { /* make sure to also print out missed steps */ for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10) { if (curVal < 100) { RTStrmPrintf(g_pStdErr, "%u%%...", curVal); RTStrmFlush(g_pStdErr); } } ulLastPercent = (ulCurrentPercent / 10) * 10; } } if (fCompleted) break; /* process async cancelation */ if (g_fCanceled && !fCanceledAlready) { hrc = progress->Cancel(); if (SUCCEEDED(hrc)) fCanceledAlready = true; else g_fCanceled = false; } /* make sure the loop is not too tight */ progress->WaitForCompletion(100); NativeEventQueue::getMainEventQueue()->processEventQueue(0); hrc = progress->COMGETTER(Completed(&fCompleted)); } /* undo signal handling */ if (fCancelable) { signal(SIGINT, SIG_DFL); signal(SIGTERM, SIG_DFL); # ifdef SIGBREAK signal(SIGBREAK, SIG_DFL); # endif } /* complete the line. */ LONG iRc = E_FAIL; hrc = progress->COMGETTER(ResultCode)(&iRc); if (SUCCEEDED(hrc)) { /* async operation completed successfully */ if (SUCCEEDED(iRc)) { if (!fDetailed) { if (fFlags == SHOW_PROGRESS_DESC) RTStrmPrintf(g_pStdErr, "ok\n"); else if (!fQuiet) RTStrmPrintf(g_pStdErr, "100%%\n"); } } else if (g_fCanceled) RTStrmPrintf(g_pStdErr, "CANCELED\n"); else { if (fDetailed) RTStrmPrintf(g_pStdErr, "Progress state: %Rhrc\n", iRc); else if (fFlags != SHOW_PROGRESS_NONE) RTStrmPrintf(g_pStdErr, "%Rhrc\n", iRc); } hrc = iRc; } else { if (!fDetailed) RTStrmPrintf(g_pStdErr, "\n"); RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc); } RTStrmFlush(g_pStdErr); return hrc; } #endif /* !VBOX_ONLY_DOCS */ int main(int argc, char *argv[]) { /* * Before we do anything, init the runtime without loading * the support driver. */ int vrc = RTR3InitExe(argc, &argv, 0); if (RT_FAILURE(vrc)) return RTMsgInitFailure(vrc); #if defined(RT_OS_WINDOWS) && !defined(VBOX_ONLY_DOCS) ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */ #endif /* * Parse the global options */ bool fShowLogo = false; bool fShowHelp = false; int iCmd = 1; int iCmdArg; const char *pszSettingsPw = NULL; const char *pszSettingsPwFile = NULL; #ifndef VBOX_ONLY_DOCS int cResponseFileArgs = 0; char **papszResponseFileArgs = NULL; char **papszNewArgv = NULL; #endif for (int i = 1; i < argc || argc <= iCmd; i++) { if ( argc <= iCmd || !strcmp(argv[i], "help") || !strcmp(argv[i], "--help") || !strcmp(argv[i], "-?") || !strcmp(argv[i], "-h") || !strcmp(argv[i], "-help")) { if (i >= argc - 1) { showLogo(g_pStdOut); printUsage(USAGE_S_ALL, RTMSGREFENTRYSTR_SCOPE_GLOBAL, g_pStdOut); return 0; } fShowLogo = true; fShowHelp = true; iCmd++; continue; } #ifndef VBOX_ONLY_DOCS if ( !strcmp(argv[i], "-V") || !strcmp(argv[i], "--version") || !strcmp(argv[i], "-v") /* deprecated */ || !strcmp(argv[i], "-version") /* deprecated */ || !strcmp(argv[i], "-Version") /* deprecated */) { /* Print version number, and do nothing else. */ RTPrintf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision()); return 0; } if (!strcmp(argv[i], "--dump-build-type")) { /* Print the build type, and do nothing else. (Used by ValKit to detect build type.) */ RTPrintf("%s\n", RTBldCfgType()); return 0; } #endif if ( !strcmp(argv[i], "--dumpopts") || !strcmp(argv[i], "-dumpopts") /* deprecated */) { /* Special option to dump really all commands, * even the ones not understood on this platform. */ printUsage(USAGE_S_DUMPOPTS, RTMSGREFENTRYSTR_SCOPE_GLOBAL, g_pStdOut); return 0; } if ( !strcmp(argv[i], "--nologo") || !strcmp(argv[i], "-q") || !strcmp(argv[i], "-nologo") /* deprecated */) { /* suppress the logo */ fShowLogo = false; iCmd++; } else if ( !strcmp(argv[i], "--detailed-progress") || !strcmp(argv[i], "-d")) { /* detailed progress report */ g_fDetailedProgress = true; iCmd++; } else if (!strcmp(argv[i], "--settingspw")) { if (i >= argc - 1) return RTMsgErrorExit(RTEXITCODE_FAILURE, "Password expected"); /* password for certain settings */ pszSettingsPw = argv[i + 1]; iCmd += 2; } else if (!strcmp(argv[i], "--settingspwfile")) { if (i >= argc-1) return RTMsgErrorExit(RTEXITCODE_FAILURE, "No password file specified"); pszSettingsPwFile = argv[i+1]; iCmd += 2; } #ifndef VBOX_ONLY_DOCS else if (argv[i][0] == '@') { if (papszResponseFileArgs) return RTMsgErrorExitFailure("Only one response file allowed"); /* Load response file, making sure it's valid UTF-8. */ char *pszResponseFile; size_t cbResponseFile; vrc = RTFileReadAllEx(&argv[i][1], 0, RTFOFF_MAX, RTFILE_RDALL_O_DENY_NONE | RTFILE_RDALL_F_TRAILING_ZERO_BYTE, (void **)&pszResponseFile, &cbResponseFile); if (RT_FAILURE(vrc)) return RTMsgErrorExitFailure("Error reading response file '%s': %Rrc", &argv[i][1], vrc); vrc = RTStrValidateEncoding(pszResponseFile); if (RT_FAILURE(vrc)) { RTFileReadAllFree(pszResponseFile, cbResponseFile); return RTMsgErrorExitFailure("Invalid response file ('%s') encoding: %Rrc", &argv[i][1], vrc); } /* Parse it. */ vrc = RTGetOptArgvFromString(&papszResponseFileArgs, &cResponseFileArgs, pszResponseFile, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH, NULL); RTFileReadAllFree(pszResponseFile, cbResponseFile); if (RT_FAILURE(vrc)) return RTMsgErrorExitFailure("Failed to parse response file '%s' (bourne shell style): %Rrc", &argv[i][1], vrc); /* Construct new argv+argc with the response file arguments inserted. */ int cNewArgs = argc + cResponseFileArgs; papszNewArgv = (char **)RTMemAllocZ((cNewArgs + 2) * sizeof(papszNewArgv[0])); if (!papszNewArgv) return RTMsgErrorExitFailure("out of memory"); memcpy(&papszNewArgv[0], &argv[0], sizeof(argv[0]) * (i + 1)); memcpy(&papszNewArgv[i + 1], papszResponseFileArgs, sizeof(argv[0]) * cResponseFileArgs); memcpy(&papszNewArgv[i + 1 + cResponseFileArgs], &argv[i + 1], sizeof(argv[0]) * (argc - i - 1 + 1)); argv = papszNewArgv; argc = argc + cResponseFileArgs; iCmd++; } #endif else break; } iCmdArg = iCmd + 1; /* * Show the logo and lookup the command and deal with fShowHelp = true. */ if (fShowLogo) showLogo(g_pStdOut); #ifndef VBOX_ONLY_DOCS PCVBMGCMD pCmd = lookupCommand(argv[iCmd]); if (pCmd && pCmd->enmCmdHelp != VBMG_CMD_TODO) setCurrentCommand(pCmd->enmCmdHelp); if ( pCmd && ( fShowHelp || ( argc - iCmdArg == 0 && pCmd->enmHelpCat != USAGE_INVALID))) { if (pCmd->enmCmdHelp == VBMG_CMD_TODO) printUsage(pCmd->enmHelpCat, RTMSGREFENTRYSTR_SCOPE_GLOBAL, g_pStdOut); else if (fShowHelp) printHelp(g_pStdOut); else printUsage(g_pStdOut); return RTEXITCODE_FAILURE; /* error */ } if (!pCmd) { if (!strcmp(argv[iCmd], "commands")) { RTPrintf("commands:\n"); for (unsigned i = 0; i < RT_ELEMENTS(g_aCommands); i++) if ( i == 0 /* skip backwards compatibility entries */ || (g_aCommands[i].enmHelpCat != USAGE_S_NEWCMD ? g_aCommands[i].enmHelpCat != g_aCommands[i - 1].enmHelpCat : g_aCommands[i].enmCmdHelp != g_aCommands[i - 1].enmCmdHelp)) RTPrintf(" %s\n", g_aCommands[i].pszCommand); return RTEXITCODE_SUCCESS; } return errorSyntax(USAGE_S_ALL, "Invalid command '%s'", argv[iCmd]); } RTEXITCODE rcExit; if (!(pCmd->fFlags & VBMG_CMD_F_NO_COM)) { /* * Initialize COM. */ using namespace com; HRESULT hrc = com::Initialize(); if (FAILED(hrc)) { # ifdef VBOX_WITH_XPCOM if (hrc == NS_ERROR_FILE_ACCESS_DENIED) { char szHome[RTPATH_MAX] = ""; com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome)); return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome); } # endif return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM! (hrc=%Rhrc)", hrc); } /* * Get the remote VirtualBox object and create a local session object. */ rcExit = RTEXITCODE_FAILURE; ComPtr virtualBoxClient; ComPtr virtualBox; hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient); if (SUCCEEDED(hrc)) hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam()); if (SUCCEEDED(hrc)) { ComPtr session; hrc = session.createInprocObject(CLSID_Session); if (SUCCEEDED(hrc)) { /* Session secret. */ if (pszSettingsPw) CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(Bstr(pszSettingsPw).raw()), rcExit = RTEXITCODE_FAILURE); else if (pszSettingsPwFile) rcExit = settingsPasswordFile(virtualBox, pszSettingsPwFile); else rcExit = RTEXITCODE_SUCCESS; if (rcExit == RTEXITCODE_SUCCESS) { /* * Call the handler. */ HandlerArg handlerArg = { argc - iCmdArg, &argv[iCmdArg], virtualBox, session }; rcExit = pCmd->pfnHandler(&handlerArg); /* Although all handlers should always close the session if they open it, * we do it here just in case if some of the handlers contains a bug -- * leaving the direct session not closed will turn the machine state to * Aborted which may have unwanted side effects like killing the saved * state file (if the machine was in the Saved state before). */ session->UnlockMachine(); } NativeEventQueue::getMainEventQueue()->processEventQueue(0); } else { com::ErrorInfo info; RTMsgError("Failed to create a session object!"); if (!info.isFullAvailable() && !info.isBasicAvailable()) com::GluePrintRCMessage(hrc); else com::GluePrintErrorInfo(info); } } else { com::ErrorInfo info; RTMsgError("Failed to create the VirtualBox object!"); if (!info.isFullAvailable() && !info.isBasicAvailable()) { com::GluePrintRCMessage(hrc); RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start."); } else com::GluePrintErrorInfo(info); } /* * Terminate COM, make sure the virtualBox object has been released. */ virtualBox.setNull(); virtualBoxClient.setNull(); NativeEventQueue::getMainEventQueue()->processEventQueue(0); com::Shutdown(); } else { /* * The command needs no COM. */ HandlerArg handlerArg; handlerArg.argc = argc - iCmdArg; handlerArg.argv = &argv[iCmdArg]; rcExit = pCmd->pfnHandler(&handlerArg); } if (papszResponseFileArgs) { RTGetOptArgvFree(papszResponseFileArgs); RTMemFree(papszNewArgv); } return rcExit; #else /* VBOX_ONLY_DOCS */ return RTEXITCODE_SUCCESS; #endif /* VBOX_ONLY_DOCS */ }