VirtualBox

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

Last change on this file since 67954 was 64997, checked in by vboxsync, 8 years ago

bugref:8527. VBoxManage: added new command "unattended"

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette