VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp@ 76678

Last change on this file since 76678 was 76553, checked in by vboxsync, 5 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 28.9 KB
Line 
1/* $Id: VBoxManage.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VBoxManage - VirtualBox's command-line interface.
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#ifndef VBOX_ONLY_DOCS
23# include <VBox/com/com.h>
24# include <VBox/com/string.h>
25# include <VBox/com/Guid.h>
26# include <VBox/com/array.h>
27# include <VBox/com/ErrorInfo.h>
28# include <VBox/com/errorprint.h>
29# include <VBox/com/NativeEventQueue.h>
30
31# include <VBox/com/VirtualBox.h>
32#endif /* !VBOX_ONLY_DOCS */
33
34#include <VBox/version.h>
35
36#include <iprt/asm.h>
37#include <iprt/buildconfig.h>
38#include <iprt/ctype.h>
39#include <iprt/file.h>
40#include <iprt/getopt.h>
41#include <iprt/initterm.h>
42#include <iprt/path.h>
43#include <iprt/stream.h>
44#include <iprt/string.h>
45
46#include <signal.h>
47
48#include "VBoxManage.h"
49
50
51/*********************************************************************************************************************************
52* Defined Constants And Macros *
53*********************************************************************************************************************************/
54/** The command doesn't need the COM stuff. */
55#define VBMG_CMD_F_NO_COM RT_BIT_32(0)
56
57#define VBMG_CMD_TODO HELP_CMD_VBOXMANAGE_INVALID
58
59
60/*********************************************************************************************************************************
61* Structures and Typedefs *
62*********************************************************************************************************************************/
63#ifndef VBOX_ONLY_DOCS
64/**
65 * VBoxManage command descriptor.
66 */
67typedef struct VBMGCMD
68{
69 /** The command. */
70 const char *pszCommand;
71 /** The help category. */
72 USAGECATEGORY enmHelpCat;
73 /** The new help command. */
74 enum HELP_CMD_VBOXMANAGE enmCmdHelp;
75 /** The handler. */
76 RTEXITCODE (*pfnHandler)(HandlerArg *pArg);
77 /** VBMG_CMD_F_XXX, */
78 uint32_t fFlags;
79} VBMGCMD;
80/** Pointer to a const VBoxManage command descriptor. */
81typedef VBMGCMD const *PCVBMGCMD;
82#endif
83
84
85/*********************************************************************************************************************************
86* Global Variables *
87*********************************************************************************************************************************/
88/*extern*/ bool g_fDetailedProgress = false;
89
90#ifndef VBOX_ONLY_DOCS
91/** Set by the signal handler. */
92static volatile bool g_fCanceled = false;
93
94
95/**
96 * All registered command handlers
97 */
98static const VBMGCMD g_aCommands[] =
99{
100 { "internalcommands", 0, VBMG_CMD_TODO, handleInternalCommands, 0 },
101 { "list", USAGE_LIST, VBMG_CMD_TODO, handleList, 0 },
102 { "showvminfo", USAGE_SHOWVMINFO, VBMG_CMD_TODO, handleShowVMInfo, 0 },
103 { "registervm", USAGE_REGISTERVM, VBMG_CMD_TODO, handleRegisterVM, 0 },
104 { "unregistervm", USAGE_UNREGISTERVM, VBMG_CMD_TODO, handleUnregisterVM, 0 },
105 { "clonevm", USAGE_CLONEVM, VBMG_CMD_TODO, handleCloneVM, 0 },
106 { "movevm", USAGE_MOVEVM, VBMG_CMD_TODO, handleMoveVM, 0 },
107 { "mediumproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 },
108 { "hdproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, /* backward compatibility */
109 { "createmedium", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 },
110 { "createhd", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
111 { "createvdi", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
112 { "modifymedium", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 },
113 { "modifyhd", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
114 { "modifyvdi", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
115 { "clonemedium", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 },
116 { "clonehd", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
117 { "clonevdi", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
118 { "encryptmedium", USAGE_ENCRYPTMEDIUM, VBMG_CMD_TODO, handleEncryptMedium, 0 },
119 { "checkmediumpwd", USAGE_MEDIUMENCCHKPWD, VBMG_CMD_TODO, handleCheckMediumPassword, 0 },
120 { "createvm", USAGE_CREATEVM, VBMG_CMD_TODO, handleCreateVM, 0 },
121 { "modifyvm", USAGE_MODIFYVM, VBMG_CMD_TODO, handleModifyVM, 0 },
122 { "startvm", USAGE_STARTVM, VBMG_CMD_TODO, handleStartVM, 0 },
123 { "controlvm", USAGE_CONTROLVM, VBMG_CMD_TODO, handleControlVM, 0 },
124 { "unattended", USAGE_UNATTENDED, HELP_CMD_UNATTENDED, handleUnattended, 0 },
125 { "discardstate", USAGE_DISCARDSTATE, VBMG_CMD_TODO, handleDiscardState, 0 },
126 { "adoptstate", USAGE_ADOPTSTATE, VBMG_CMD_TODO, handleAdoptState, 0 },
127 { "snapshot", USAGE_SNAPSHOT, VBMG_CMD_TODO, handleSnapshot, 0 },
128 { "closemedium", USAGE_CLOSEMEDIUM, VBMG_CMD_TODO, handleCloseMedium, 0 },
129 { "storageattach", USAGE_STORAGEATTACH, VBMG_CMD_TODO, handleStorageAttach, 0 },
130 { "storagectl", USAGE_STORAGECONTROLLER,VBMG_CMD_TODO, handleStorageController, 0 },
131 { "showmediuminfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 },
132 { "showhdinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */
133 { "showvdiinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */
134 { "mediumio", USAGE_MEDIUMIO, HELP_CMD_MEDIUMIO, handleMediumIO, 0 },
135 { "getextradata", USAGE_GETEXTRADATA, VBMG_CMD_TODO, handleGetExtraData, 0 },
136 { "setextradata", USAGE_SETEXTRADATA, VBMG_CMD_TODO, handleSetExtraData, 0 },
137 { "setproperty", USAGE_SETPROPERTY, VBMG_CMD_TODO, handleSetProperty, 0 },
138 { "usbfilter", USAGE_USBFILTER, VBMG_CMD_TODO, handleUSBFilter, 0 },
139 { "sharedfolder", USAGE_SHAREDFOLDER, VBMG_CMD_TODO, handleSharedFolder, 0 },
140#ifdef VBOX_WITH_GUEST_PROPS
141 { "guestproperty", USAGE_GUESTPROPERTY, VBMG_CMD_TODO, handleGuestProperty, 0 },
142#endif
143#ifdef VBOX_WITH_GUEST_CONTROL
144 { "guestcontrol", USAGE_GUESTCONTROL, VBMG_CMD_TODO, handleGuestControl, 0 },
145#endif
146 { "metrics", USAGE_METRICS, VBMG_CMD_TODO, handleMetrics, 0 },
147 { "import", USAGE_IMPORTAPPLIANCE, VBMG_CMD_TODO, handleImportAppliance, 0 },
148 { "export", USAGE_EXPORTAPPLIANCE, VBMG_CMD_TODO, handleExportAppliance, 0 },
149#ifdef VBOX_WITH_NETFLT
150 { "hostonlyif", USAGE_HOSTONLYIFS, VBMG_CMD_TODO, handleHostonlyIf, 0 },
151#endif
152 { "dhcpserver", USAGE_DHCPSERVER, VBMG_CMD_TODO, handleDHCPServer, 0 },
153#ifdef VBOX_WITH_NAT_SERVICE
154 { "natnetwork", USAGE_NATNETWORK, VBMG_CMD_TODO, handleNATNetwork, 0 },
155#endif
156 { "extpack", USAGE_EXTPACK, HELP_CMD_EXTPACK, handleExtPack, 0 },
157 { "bandwidthctl", USAGE_BANDWIDTHCONTROL, VBMG_CMD_TODO, handleBandwidthControl, 0 },
158 { "debugvm", USAGE_DEBUGVM, HELP_CMD_DEBUGVM, handleDebugVM, 0 },
159 { "convertfromraw", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM },
160 { "convertdd", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM },
161 { "usbdevsource", USAGE_USBDEVSOURCE, VBMG_CMD_TODO, handleUSBDevSource, 0 }
162};
163
164
165/**
166 * Looks up a command by name.
167 *
168 * @returns Pointer to the command structure.
169 * @param pszCommand Name of the command.
170 */
171static PCVBMGCMD lookupCommand(const char *pszCommand)
172{
173 if (pszCommand)
174 for (uint32_t i = 0; i < RT_ELEMENTS(g_aCommands); i++)
175 if (!strcmp(g_aCommands[i].pszCommand, pszCommand))
176 return &g_aCommands[i];
177 return NULL;
178}
179
180
181/**
182 * Signal handler that sets g_fCanceled.
183 *
184 * This can be executed on any thread in the process, on Windows it may even be
185 * a thread dedicated to delivering this signal. Do not doing anything
186 * unnecessary here.
187 */
188static void showProgressSignalHandler(int iSignal)
189{
190 NOREF(iSignal);
191 ASMAtomicWriteBool(&g_fCanceled, true);
192}
193
194/**
195 * Print out progress on the console.
196 *
197 * This runs the main event queue every now and then to prevent piling up
198 * unhandled things (which doesn't cause real problems, just makes things
199 * react a little slower than in the ideal case).
200 */
201HRESULT showProgress(ComPtr<IProgress> progress)
202{
203 using namespace com;
204
205 BOOL fCompleted = FALSE;
206 ULONG ulCurrentPercent = 0;
207 ULONG ulLastPercent = 0;
208
209 ULONG ulLastOperationPercent = (ULONG)-1;
210
211 ULONG ulLastOperation = (ULONG)-1;
212 Bstr bstrOperationDescription;
213
214 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
215
216 ULONG cOperations = 1;
217 HRESULT hrc = progress->COMGETTER(OperationCount)(&cOperations);
218 if (FAILED(hrc))
219 {
220 RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc);
221 RTStrmFlush(g_pStdErr);
222 return hrc;
223 }
224
225 /*
226 * Note: Outputting the progress info to stderr (g_pStdErr) is intentional
227 * to not get intermixed with other (raw) stdout data which might get
228 * written in the meanwhile.
229 */
230
231 if (!g_fDetailedProgress)
232 {
233 RTStrmPrintf(g_pStdErr, "0%%...");
234 RTStrmFlush(g_pStdErr);
235 }
236
237 /* setup signal handling if cancelable */
238 bool fCanceledAlready = false;
239 BOOL fCancelable;
240 hrc = progress->COMGETTER(Cancelable)(&fCancelable);
241 if (FAILED(hrc))
242 fCancelable = FALSE;
243 if (fCancelable)
244 {
245 signal(SIGINT, showProgressSignalHandler);
246 signal(SIGTERM, showProgressSignalHandler);
247#ifdef SIGBREAK
248 signal(SIGBREAK, showProgressSignalHandler);
249#endif
250 }
251
252 hrc = progress->COMGETTER(Completed(&fCompleted));
253 while (SUCCEEDED(hrc))
254 {
255 progress->COMGETTER(Percent(&ulCurrentPercent));
256
257 if (g_fDetailedProgress)
258 {
259 ULONG ulOperation = 1;
260 hrc = progress->COMGETTER(Operation)(&ulOperation);
261 if (FAILED(hrc))
262 break;
263 ULONG ulCurrentOperationPercent = 0;
264 hrc = progress->COMGETTER(OperationPercent(&ulCurrentOperationPercent));
265 if (FAILED(hrc))
266 break;
267
268 if (ulLastOperation != ulOperation)
269 {
270 hrc = progress->COMGETTER(OperationDescription(bstrOperationDescription.asOutParam()));
271 if (FAILED(hrc))
272 break;
273 ulLastPercent = (ULONG)-1; // force print
274 ulLastOperation = ulOperation;
275 }
276
277 if ( ulCurrentPercent != ulLastPercent
278 || ulCurrentOperationPercent != ulLastOperationPercent
279 )
280 {
281 LONG lSecsRem = 0;
282 progress->COMGETTER(TimeRemaining)(&lSecsRem);
283
284 RTStrmPrintf(g_pStdErr, "(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n", ulOperation + 1, cOperations,
285 bstrOperationDescription.raw(), ulCurrentOperationPercent, ulCurrentPercent, lSecsRem);
286 ulLastPercent = ulCurrentPercent;
287 ulLastOperationPercent = ulCurrentOperationPercent;
288 }
289 }
290 else
291 {
292 /* did we cross a 10% mark? */
293 if (ulCurrentPercent / 10 > ulLastPercent / 10)
294 {
295 /* make sure to also print out missed steps */
296 for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10)
297 {
298 if (curVal < 100)
299 {
300 RTStrmPrintf(g_pStdErr, "%u%%...", curVal);
301 RTStrmFlush(g_pStdErr);
302 }
303 }
304 ulLastPercent = (ulCurrentPercent / 10) * 10;
305 }
306 }
307 if (fCompleted)
308 break;
309
310 /* process async cancelation */
311 if (g_fCanceled && !fCanceledAlready)
312 {
313 hrc = progress->Cancel();
314 if (SUCCEEDED(hrc))
315 fCanceledAlready = true;
316 else
317 g_fCanceled = false;
318 }
319
320 /* make sure the loop is not too tight */
321 progress->WaitForCompletion(100);
322
323 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
324 hrc = progress->COMGETTER(Completed(&fCompleted));
325 }
326
327 /* undo signal handling */
328 if (fCancelable)
329 {
330 signal(SIGINT, SIG_DFL);
331 signal(SIGTERM, SIG_DFL);
332# ifdef SIGBREAK
333 signal(SIGBREAK, SIG_DFL);
334# endif
335 }
336
337 /* complete the line. */
338 LONG iRc = E_FAIL;
339 hrc = progress->COMGETTER(ResultCode)(&iRc);
340 if (SUCCEEDED(hrc))
341 {
342 if (SUCCEEDED(iRc))
343 RTStrmPrintf(g_pStdErr, "100%%\n");
344 else if (g_fCanceled)
345 RTStrmPrintf(g_pStdErr, "CANCELED\n");
346 else
347 {
348 if (!g_fDetailedProgress)
349 RTStrmPrintf(g_pStdErr, "\n");
350 RTStrmPrintf(g_pStdErr, "Progress state: %Rhrc\n", iRc);
351 }
352 hrc = iRc;
353 }
354 else
355 {
356 if (!g_fDetailedProgress)
357 RTStrmPrintf(g_pStdErr, "\n");
358 RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc);
359 }
360 RTStrmFlush(g_pStdErr);
361 return hrc;
362}
363
364RTEXITCODE readPasswordFile(const char *pszFilename, com::Utf8Str *pPasswd)
365{
366 size_t cbFile;
367 char szPasswd[512];
368 int vrc = VINF_SUCCESS;
369 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
370 bool fStdIn = !strcmp(pszFilename, "stdin");
371 PRTSTREAM pStrm;
372 if (!fStdIn)
373 vrc = RTStrmOpen(pszFilename, "r", &pStrm);
374 else
375 pStrm = g_pStdIn;
376 if (RT_SUCCESS(vrc))
377 {
378 vrc = RTStrmReadEx(pStrm, szPasswd, sizeof(szPasswd)-1, &cbFile);
379 if (RT_SUCCESS(vrc))
380 {
381 if (cbFile >= sizeof(szPasswd)-1)
382 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Provided password in file '%s' is too long", pszFilename);
383 else
384 {
385 unsigned i;
386 for (i = 0; i < cbFile && !RT_C_IS_CNTRL(szPasswd[i]); i++)
387 ;
388 szPasswd[i] = '\0';
389 *pPasswd = szPasswd;
390 }
391 }
392 else
393 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot read password from file '%s': %Rrc", pszFilename, vrc);
394 if (!fStdIn)
395 RTStrmClose(pStrm);
396 }
397 else
398 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open password file '%s' (%Rrc)", pszFilename, vrc);
399
400 return rcExit;
401}
402
403static RTEXITCODE settingsPasswordFile(ComPtr<IVirtualBox> virtualBox, const char *pszFilename)
404{
405 com::Utf8Str passwd;
406 RTEXITCODE rcExit = readPasswordFile(pszFilename, &passwd);
407 if (rcExit == RTEXITCODE_SUCCESS)
408 {
409 CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(com::Bstr(passwd).raw()), rcExit = RTEXITCODE_FAILURE);
410 }
411
412 return rcExit;
413}
414
415RTEXITCODE readPasswordFromConsole(com::Utf8Str *pPassword, const char *pszPrompt, ...)
416{
417 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
418 char aszPwdInput[_1K] = { 0 };
419 va_list vaArgs;
420
421 va_start(vaArgs, pszPrompt);
422 int vrc = RTStrmPrintfV(g_pStdOut, pszPrompt, vaArgs);
423 if (RT_SUCCESS(vrc))
424 {
425 bool fEchoOld = false;
426 vrc = RTStrmInputGetEchoChars(g_pStdIn, &fEchoOld);
427 if (RT_SUCCESS(vrc))
428 {
429 vrc = RTStrmInputSetEchoChars(g_pStdIn, false);
430 if (RT_SUCCESS(vrc))
431 {
432 vrc = RTStrmGetLine(g_pStdIn, &aszPwdInput[0], sizeof(aszPwdInput));
433 if (RT_SUCCESS(vrc))
434 *pPassword = aszPwdInput;
435 else
436 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed read password from command line (%Rrc)", vrc);
437
438 int vrc2 = RTStrmInputSetEchoChars(g_pStdIn, fEchoOld);
439 AssertRC(vrc2);
440 }
441 else
442 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to disable echoing typed characters (%Rrc)", vrc);
443 }
444 else
445 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to retrieve echo setting (%Rrc)", vrc);
446
447 RTStrmPutStr(g_pStdOut, "\n");
448 }
449 else
450 rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to print prompt (%Rrc)", vrc);
451 va_end(vaArgs);
452
453 return rcExit;
454}
455
456#endif /* !VBOX_ONLY_DOCS */
457
458
459int main(int argc, char *argv[])
460{
461 /*
462 * Before we do anything, init the runtime without loading
463 * the support driver.
464 */
465 int vrc = RTR3InitExe(argc, &argv, 0);
466 if (RT_FAILURE(vrc))
467 return RTMsgInitFailure(vrc);
468#if defined(RT_OS_WINDOWS) && !defined(VBOX_ONLY_DOCS)
469 ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */
470#endif
471
472 /*
473 * Parse the global options
474 */
475 bool fShowLogo = false;
476 bool fShowHelp = false;
477 int iCmd = 1;
478 int iCmdArg;
479 const char *pszSettingsPw = NULL;
480 const char *pszSettingsPwFile = NULL;
481#ifndef VBOX_ONLY_DOCS
482 int cResponseFileArgs = 0;
483 char **papszResponseFileArgs = NULL;
484 char **papszNewArgv = NULL;
485#endif
486
487 for (int i = 1; i < argc || argc <= iCmd; i++)
488 {
489 if ( argc <= iCmd
490 || !strcmp(argv[i], "help")
491 || !strcmp(argv[i], "--help")
492 || !strcmp(argv[i], "-?")
493 || !strcmp(argv[i], "-h")
494 || !strcmp(argv[i], "-help"))
495 {
496 if (i >= argc - 1)
497 {
498 showLogo(g_pStdOut);
499 printUsage(USAGE_ALL, ~0U, g_pStdOut);
500 return 0;
501 }
502 fShowLogo = true;
503 fShowHelp = true;
504 iCmd++;
505 continue;
506 }
507
508#ifndef VBOX_ONLY_DOCS
509 if ( !strcmp(argv[i], "-V")
510 || !strcmp(argv[i], "--version")
511 || !strcmp(argv[i], "-v") /* deprecated */
512 || !strcmp(argv[i], "-version") /* deprecated */
513 || !strcmp(argv[i], "-Version") /* deprecated */)
514 {
515 /* Print version number, and do nothing else. */
516 RTPrintf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision());
517 return 0;
518 }
519#endif
520
521 if ( !strcmp(argv[i], "--dumpopts")
522 || !strcmp(argv[i], "-dumpopts") /* deprecated */)
523 {
524 /* Special option to dump really all commands,
525 * even the ones not understood on this platform. */
526 printUsage(USAGE_DUMPOPTS, ~0U, g_pStdOut);
527 return 0;
528 }
529
530 if ( !strcmp(argv[i], "--nologo")
531 || !strcmp(argv[i], "-q")
532 || !strcmp(argv[i], "-nologo") /* deprecated */)
533 {
534 /* suppress the logo */
535 fShowLogo = false;
536 iCmd++;
537 }
538 else if ( !strcmp(argv[i], "--detailed-progress")
539 || !strcmp(argv[i], "-d"))
540 {
541 /* detailed progress report */
542 g_fDetailedProgress = true;
543 iCmd++;
544 }
545 else if (!strcmp(argv[i], "--settingspw"))
546 {
547 if (i >= argc - 1)
548 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Password expected");
549 /* password for certain settings */
550 pszSettingsPw = argv[i + 1];
551 iCmd += 2;
552 }
553 else if (!strcmp(argv[i], "--settingspwfile"))
554 {
555 if (i >= argc-1)
556 return RTMsgErrorExit(RTEXITCODE_FAILURE, "No password file specified");
557 pszSettingsPwFile = argv[i+1];
558 iCmd += 2;
559 }
560#ifndef VBOX_ONLY_DOCS
561 else if (argv[i][0] == '@')
562 {
563 if (papszResponseFileArgs)
564 return RTMsgErrorExitFailure("Only one response file allowed");
565
566 /* Load response file, making sure it's valid UTF-8. */
567 char *pszResponseFile;
568 size_t cbResponseFile;
569 vrc = RTFileReadAllEx(&argv[i][1], 0, RTFOFF_MAX, RTFILE_RDALL_O_DENY_NONE | RTFILE_RDALL_F_TRAILING_ZERO_BYTE,
570 (void **)&pszResponseFile, &cbResponseFile);
571 if (RT_FAILURE(vrc))
572 return RTMsgErrorExitFailure("Error reading response file '%s': %Rrc", &argv[i][1], vrc);
573 vrc = RTStrValidateEncoding(pszResponseFile);
574 if (RT_FAILURE(vrc))
575 {
576 RTFileReadAllFree(pszResponseFile, cbResponseFile);
577 return RTMsgErrorExitFailure("Invalid response file ('%s') encoding: %Rrc", &argv[i][1], vrc);
578 }
579
580 /* Parse it. */
581 vrc = RTGetOptArgvFromString(&papszResponseFileArgs, &cResponseFileArgs, pszResponseFile,
582 RTGETOPTARGV_CNV_QUOTE_BOURNE_SH, NULL);
583 RTFileReadAllFree(pszResponseFile, cbResponseFile);
584 if (RT_FAILURE(vrc))
585 return RTMsgErrorExitFailure("Failed to parse response file '%s' (bourne shell style): %Rrc", &argv[i][1], vrc);
586
587 /* Construct new argv+argc with the response file arguments inserted. */
588 int cNewArgs = argc + cResponseFileArgs;
589 papszNewArgv = (char **)RTMemAllocZ((cNewArgs + 2) * sizeof(papszNewArgv[0]));
590 if (!papszNewArgv)
591 return RTMsgErrorExitFailure("out of memory");
592 memcpy(&papszNewArgv[0], &argv[0], sizeof(argv[0]) * (i + 1));
593 memcpy(&papszNewArgv[i + 1], papszResponseFileArgs, sizeof(argv[0]) * cResponseFileArgs);
594 memcpy(&papszNewArgv[i + 1 + cResponseFileArgs], &argv[i + 1], sizeof(argv[0]) * (argc - i - 1 + 1));
595 argv = papszNewArgv;
596 argc = argc + cResponseFileArgs;
597
598 iCmd++;
599 }
600#endif
601 else
602 break;
603 }
604
605 iCmdArg = iCmd + 1;
606
607 /*
608 * Show the logo and lookup the command and deal with fShowHelp = true.
609 */
610 if (fShowLogo)
611 showLogo(g_pStdOut);
612
613#ifndef VBOX_ONLY_DOCS
614 PCVBMGCMD pCmd = lookupCommand(argv[iCmd]);
615 if (pCmd && pCmd->enmCmdHelp != VBMG_CMD_TODO)
616 setCurrentCommand(pCmd->enmCmdHelp);
617
618 if ( pCmd
619 && ( fShowHelp
620 || ( argc - iCmdArg == 0
621 && pCmd->enmHelpCat != 0)))
622 {
623 if (pCmd->enmCmdHelp == VBMG_CMD_TODO)
624 printUsage(pCmd->enmHelpCat, ~0U, g_pStdOut);
625 else if (fShowHelp)
626 printHelp(g_pStdOut);
627 else
628 printUsage(g_pStdOut);
629 return RTEXITCODE_FAILURE; /* error */
630 }
631 if (!pCmd)
632 {
633 if (!strcmp(argv[iCmd], "commands"))
634 {
635 RTPrintf("commands:\n");
636 for (unsigned i = 0; i < RT_ELEMENTS(g_aCommands); i++)
637 if ( i == 0 /* skip backwards compatibility entries */
638 || g_aCommands[i].enmHelpCat != g_aCommands[i - 1].enmHelpCat)
639 RTPrintf(" %s\n", g_aCommands[i].pszCommand);
640 return RTEXITCODE_SUCCESS;
641 }
642 return errorSyntax(USAGE_ALL, "Invalid command '%s'", argv[iCmd]);
643 }
644
645 RTEXITCODE rcExit;
646 if (!(pCmd->fFlags & VBMG_CMD_F_NO_COM))
647 {
648 /*
649 * Initialize COM.
650 */
651 using namespace com;
652 HRESULT hrc = com::Initialize();
653 if (FAILED(hrc))
654 {
655# ifdef VBOX_WITH_XPCOM
656 if (hrc == NS_ERROR_FILE_ACCESS_DENIED)
657 {
658 char szHome[RTPATH_MAX] = "";
659 com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
660 return RTMsgErrorExit(RTEXITCODE_FAILURE,
661 "Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
662 }
663# endif
664 return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM! (hrc=%Rhrc)", hrc);
665 }
666
667
668 /*
669 * Get the remote VirtualBox object and create a local session object.
670 */
671 rcExit = RTEXITCODE_FAILURE;
672 ComPtr<IVirtualBoxClient> virtualBoxClient;
673 ComPtr<IVirtualBox> virtualBox;
674 hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
675 if (SUCCEEDED(hrc))
676 hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
677 if (SUCCEEDED(hrc))
678 {
679 ComPtr<ISession> session;
680 hrc = session.createInprocObject(CLSID_Session);
681 if (SUCCEEDED(hrc))
682 {
683 /* Session secret. */
684 if (pszSettingsPw)
685 CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(Bstr(pszSettingsPw).raw()), rcExit = RTEXITCODE_FAILURE);
686 else if (pszSettingsPwFile)
687 rcExit = settingsPasswordFile(virtualBox, pszSettingsPwFile);
688 else
689 rcExit = RTEXITCODE_SUCCESS;
690 if (rcExit == RTEXITCODE_SUCCESS)
691 {
692 /*
693 * Call the handler.
694 */
695 HandlerArg handlerArg = { argc - iCmdArg, &argv[iCmdArg], virtualBox, session };
696 rcExit = pCmd->pfnHandler(&handlerArg);
697
698 /* Although all handlers should always close the session if they open it,
699 * we do it here just in case if some of the handlers contains a bug --
700 * leaving the direct session not closed will turn the machine state to
701 * Aborted which may have unwanted side effects like killing the saved
702 * state file (if the machine was in the Saved state before). */
703 session->UnlockMachine();
704 }
705
706 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
707 }
708 else
709 {
710 com::ErrorInfo info;
711 RTMsgError("Failed to create a session object!");
712 if (!info.isFullAvailable() && !info.isBasicAvailable())
713 com::GluePrintRCMessage(hrc);
714 else
715 com::GluePrintErrorInfo(info);
716 }
717 }
718 else
719 {
720 com::ErrorInfo info;
721 RTMsgError("Failed to create the VirtualBox object!");
722 if (!info.isFullAvailable() && !info.isBasicAvailable())
723 {
724 com::GluePrintRCMessage(hrc);
725 RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start.");
726 }
727 else
728 com::GluePrintErrorInfo(info);
729 }
730
731 /*
732 * Terminate COM, make sure the virtualBox object has been released.
733 */
734 virtualBox.setNull();
735 virtualBoxClient.setNull();
736 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
737 com::Shutdown();
738 }
739 else
740 {
741 /*
742 * The command needs no COM.
743 */
744 HandlerArg handlerArg;
745 handlerArg.argc = argc - iCmdArg;
746 handlerArg.argv = &argv[iCmdArg];
747 rcExit = pCmd->pfnHandler(&handlerArg);
748 }
749
750 if (papszResponseFileArgs)
751 {
752 RTGetOptArgvFree(papszResponseFileArgs);
753 RTMemFree(papszNewArgv);
754 }
755
756 return rcExit;
757#else /* VBOX_ONLY_DOCS */
758 return RTEXITCODE_SUCCESS;
759#endif /* VBOX_ONLY_DOCS */
760}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use