VBoxManage.cpp@ 56927

Last change on this file since 56927 was 56466, checked in by vboxsync, 10 years ago
debugvm manpage, refsect2 titles, bunch of other hacking.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.0 KB

Line
1	/* $Id: VBoxManage.cpp 56466 2015-06-16 23:46:25Z vboxsync $ */
2	/** @file
3	* VBoxManage - VirtualBox's command-line interface.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 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	*/
66	typedef 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. */
80	typedef 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. */
91	static volatile bool g_fCanceled = false;
92
93	# ifdef RT_OS_WINDOWS
94	// Required for ATL
95	static CComModule _Module;
96	# endif
97
98	/**
99	* All registered command handlers
100	*/
101	static const VBMGCMD g_aCommands[] =
102	{
103	{ "internalcommands", 0, VBMG_CMD_TODO, handleInternalCommands, 0 },
104	{ "list", USAGE_LIST, VBMG_CMD_TODO, handleList, 0 },
105	{ "showvminfo", USAGE_SHOWVMINFO, VBMG_CMD_TODO, handleShowVMInfo, 0 },
106	{ "registervm", USAGE_REGISTERVM, VBMG_CMD_TODO, handleRegisterVM, 0 },
107	{ "unregistervm", USAGE_UNREGISTERVM, VBMG_CMD_TODO, handleUnregisterVM, 0 },
108	{ "clonevm", USAGE_CLONEVM, VBMG_CMD_TODO, handleCloneVM, 0 },
109	{ "mediumproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 },
110	{ "hdproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, /* backward compatibility */
111	{ "createmedium", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 },
112	{ "createhd", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
113	{ "createvdi", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
114	{ "modifymedium", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 },
115	{ "modifyhd", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
116	{ "modifyvdi", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
117	{ "clonemedium", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 },
118	{ "clonehd", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
119	{ "clonevdi", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
120	{ "encryptmedium", USAGE_ENCRYPTMEDIUM, VBMG_CMD_TODO, handleEncryptMedium, 0 },
121	{ "checkmediumpwd", USAGE_MEDIUMENCCHKPWD, VBMG_CMD_TODO, handleCheckMediumPassword, 0 },
122	{ "createvm", USAGE_CREATEVM, VBMG_CMD_TODO, handleCreateVM, 0 },
123	{ "modifyvm", USAGE_MODIFYVM, VBMG_CMD_TODO, handleModifyVM, 0 },
124	{ "startvm", USAGE_STARTVM, VBMG_CMD_TODO, handleStartVM, 0 },
125	{ "controlvm", USAGE_CONTROLVM, VBMG_CMD_TODO, handleControlVM, 0 },
126	{ "discardstate", USAGE_DISCARDSTATE, VBMG_CMD_TODO, handleDiscardState, 0 },
127	{ "adoptstate", USAGE_ADOPTSTATE, VBMG_CMD_TODO, handleAdoptState, 0 },
128	{ "snapshot", USAGE_SNAPSHOT, VBMG_CMD_TODO, handleSnapshot, 0 },
129	{ "closemedium", USAGE_CLOSEMEDIUM, VBMG_CMD_TODO, handleCloseMedium, 0 },
130	{ "storageattach", USAGE_STORAGEATTACH, VBMG_CMD_TODO, handleStorageAttach, 0 },
131	{ "storagectl", USAGE_STORAGECONTROLLER,VBMG_CMD_TODO, handleStorageController, 0 },
132	{ "showmediuminfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 },
133	{ "showhdinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */
134	{ "showvdiinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */
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	};
162
163
164	/**
165	* Looks up a command by name.
166	*
167	* @returns Pointer to the command structure.
168	* @param pszCommand Name of the command.
169	*/
170	static PCVBMGCMD lookupCommand(const char *pszCommand)
171	{
172	if (pszCommand)
173	for (uint32_t i = 0; i < RT_ELEMENTS(g_aCommands); i++)
174	if (!strcmp(g_aCommands[i].pszCommand, pszCommand))
175	return &g_aCommands[i];
176	return NULL;
177	}
178
179
180	/**
181	* Signal handler that sets g_fCanceled.
182	*
183	* This can be executed on any thread in the process, on Windows it may even be
184	* a thread dedicated to delivering this signal. Do not doing anything
185	* unnecessary here.
186	*/
187	static void showProgressSignalHandler(int iSignal)
188	{
189	NOREF(iSignal);
190	ASMAtomicWriteBool(&g_fCanceled, true);
191	}
192
193	/**
194	* Print out progress on the console.
195	*
196	* This runs the main event queue every now and then to prevent piling up
197	* unhandled things (which doesn't cause real problems, just makes things
198	* react a little slower than in the ideal case).
199	*/
200	HRESULT showProgress(ComPtr<IProgress> progress)
201	{
202	using namespace com;
203
204	BOOL fCompleted = FALSE;
205	ULONG ulCurrentPercent = 0;
206	ULONG ulLastPercent = 0;
207
208	ULONG ulLastOperationPercent = (ULONG)-1;
209
210	ULONG ulLastOperation = (ULONG)-1;
211	Bstr bstrOperationDescription;
212
213	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
214
215	ULONG cOperations = 1;
216	HRESULT hrc = progress->COMGETTER(OperationCount)(&cOperations);
217	if (FAILED(hrc))
218	{
219	RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc);
220	RTStrmFlush(g_pStdErr);
221	return hrc;
222	}
223
224	/*
225	* Note: Outputting the progress info to stderr (g_pStdErr) is intentional
226	* to not get intermixed with other (raw) stdout data which might get
227	* written in the meanwhile.
228	*/
229
230	if (!g_fDetailedProgress)
231	{
232	RTStrmPrintf(g_pStdErr, "0%%...");
233	RTStrmFlush(g_pStdErr);
234	}
235
236	/* setup signal handling if cancelable */
237	bool fCanceledAlready = false;
238	BOOL fCancelable;
239	hrc = progress->COMGETTER(Cancelable)(&fCancelable);
240	if (FAILED(hrc))
241	fCancelable = FALSE;
242	if (fCancelable)
243	{
244	signal(SIGINT, showProgressSignalHandler);
245	#ifdef SIGBREAK
246	signal(SIGBREAK, showProgressSignalHandler);
247	#endif
248	}
249
250	hrc = progress->COMGETTER(Completed(&fCompleted));
251	while (SUCCEEDED(hrc))
252	{
253	progress->COMGETTER(Percent(&ulCurrentPercent));
254
255	if (g_fDetailedProgress)
256	{
257	ULONG ulOperation = 1;
258	hrc = progress->COMGETTER(Operation)(&ulOperation);
259	if (FAILED(hrc))
260	break;
261	ULONG ulCurrentOperationPercent = 0;
262	hrc = progress->COMGETTER(OperationPercent(&ulCurrentOperationPercent));
263	if (FAILED(hrc))
264	break;
265
266	if (ulLastOperation != ulOperation)
267	{
268	hrc = progress->COMGETTER(OperationDescription(bstrOperationDescription.asOutParam()));
269	if (FAILED(hrc))
270	break;
271	ulLastPercent = (ULONG)-1; // force print
272	ulLastOperation = ulOperation;
273	}
274
275	if ( ulCurrentPercent != ulLastPercent
276	\|\| ulCurrentOperationPercent != ulLastOperationPercent
277	)
278	{
279	LONG lSecsRem = 0;
280	progress->COMGETTER(TimeRemaining)(&lSecsRem);
281
282	RTStrmPrintf(g_pStdErr, "(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n", ulOperation + 1, cOperations,
283	bstrOperationDescription.raw(), ulCurrentOperationPercent, ulCurrentPercent, lSecsRem);
284	ulLastPercent = ulCurrentPercent;
285	ulLastOperationPercent = ulCurrentOperationPercent;
286	}
287	}
288	else
289	{
290	/* did we cross a 10% mark? */
291	if (ulCurrentPercent / 10 > ulLastPercent / 10)
292	{
293	/* make sure to also print out missed steps */
294	for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10)
295	{
296	if (curVal < 100)
297	{
298	RTStrmPrintf(g_pStdErr, "%u%%...", curVal);
299	RTStrmFlush(g_pStdErr);
300	}
301	}
302	ulLastPercent = (ulCurrentPercent / 10) * 10;
303	}
304	}
305	if (fCompleted)
306	break;
307
308	/* process async cancelation */
309	if (g_fCanceled && !fCanceledAlready)
310	{
311	hrc = progress->Cancel();
312	if (SUCCEEDED(hrc))
313	fCanceledAlready = true;
314	else
315	g_fCanceled = false;
316	}
317
318	/* make sure the loop is not too tight */
319	progress->WaitForCompletion(100);
320
321	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
322	hrc = progress->COMGETTER(Completed(&fCompleted));
323	}
324
325	/* undo signal handling */
326	if (fCancelable)
327	{
328	signal(SIGINT, 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
361	RTEXITCODE 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
400	static 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
412	RTEXITCODE 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
456	int 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
464	/*
465	* Parse the global options
466	*/
467	bool fShowLogo = false;
468	bool fShowHelp = false;
469	int iCmd = 1;
470	int iCmdArg;
471	const char *pszSettingsPw = NULL;
472	const char *pszSettingsPwFile = NULL;
473
474	for (int i = 1; i < argc \|\| argc <= iCmd; i++)
475	{
476	if ( argc <= iCmd
477	\|\| !strcmp(argv[i], "help")
478	\|\| !strcmp(argv[i], "--help")
479	\|\| !strcmp(argv[i], "-?")
480	\|\| !strcmp(argv[i], "-h")
481	\|\| !strcmp(argv[i], "-help"))
482	{
483	if (i >= argc - 1)
484	{
485	showLogo(g_pStdOut);
486	printUsage(USAGE_ALL, ~0U, g_pStdOut);
487	return 0;
488	}
489	fShowLogo = true;
490	fShowHelp = true;
491	iCmd++;
492	continue;
493	}
494
495	if ( !strcmp(argv[i], "-V")
496	\|\| !strcmp(argv[i], "--version")
497	\|\| !strcmp(argv[i], "-v") /* deprecated */
498	\|\| !strcmp(argv[i], "-version") /* deprecated */
499	\|\| !strcmp(argv[i], "-Version") /* deprecated */)
500	{
501	/* Print version number, and do nothing else. */
502	RTPrintf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision());
503	return 0;
504	}
505
506	if ( !strcmp(argv[i], "--dumpopts")
507	\|\| !strcmp(argv[i], "-dumpopts") /* deprecated */)
508	{
509	/* Special option to dump really all commands,
510	* even the ones not understood on this platform. */
511	printUsage(USAGE_DUMPOPTS, ~0U, g_pStdOut);
512	return 0;
513	}
514
515	if ( !strcmp(argv[i], "--nologo")
516	\|\| !strcmp(argv[i], "-q")
517	\|\| !strcmp(argv[i], "-nologo") /* deprecated */)
518	{
519	/* suppress the logo */
520	fShowLogo = false;
521	iCmd++;
522	}
523	else if ( !strcmp(argv[i], "--detailed-progress")
524	\|\| !strcmp(argv[i], "-d"))
525	{
526	/* detailed progress report */
527	g_fDetailedProgress = true;
528	iCmd++;
529	}
530	else if (!strcmp(argv[i], "--settingspw"))
531	{
532	if (i >= argc - 1)
533	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Password expected");
534	/* password for certain settings */
535	pszSettingsPw = argv[i + 1];
536	iCmd += 2;
537	}
538	else if (!strcmp(argv[i], "--settingspwfile"))
539	{
540	if (i >= argc-1)
541	return RTMsgErrorExit(RTEXITCODE_FAILURE, "No password file specified");
542	pszSettingsPwFile = argv[i+1];
543	iCmd += 2;
544	}
545	else
546	break;
547	}
548
549	iCmdArg = iCmd + 1;
550
551	/*
552	* Show the logo and lookup the command and deal with fShowHelp = true.
553	*/
554	if (fShowLogo)
555	showLogo(g_pStdOut);
556
557	#ifndef VBOX_ONLY_DOCS
558	PCVBMGCMD pCmd = lookupCommand(argv[iCmd]);
559	if (pCmd && pCmd->enmCmdHelp != VBMG_CMD_TODO)
560	setCurrentCommand(pCmd->enmCmdHelp);
561
562	if ( pCmd
563	&& ( fShowHelp
564	\|\| ( argc - iCmdArg == 0
565	&& pCmd->enmHelpCat != 0)))
566	{
567	if (pCmd->enmCmdHelp == VBMG_CMD_TODO)
568	printUsage(pCmd->enmHelpCat, ~0U, g_pStdOut);
569	else if (fShowHelp)
570	printHelp(g_pStdOut);
571	else
572	printUsage(g_pStdOut);
573	return RTEXITCODE_FAILURE; /* error */
574	}
575	if (!pCmd)
576	{
577	if (!strcmp(argv[iCmd], "commands"))
578	{
579	RTPrintf("commands:\n");
580	for (unsigned i = 0; i < RT_ELEMENTS(g_aCommands); i++)
581	if ( i == 0 /* skip backwards compatibility entries */
582	\|\| g_aCommands[i].enmHelpCat != g_aCommands[i - 1].enmHelpCat)
583	RTPrintf(" %s\n", g_aCommands[i].pszCommand);
584	return RTEXITCODE_SUCCESS;
585	}
586	return errorSyntax(USAGE_ALL, "Invalid command '%s'", argv[iCmd]);
587	}
588
589	RTEXITCODE rcExit;
590	if (!(pCmd->fFlags & VBMG_CMD_F_NO_COM))
591	{
592	/*
593	* Initialize COM.
594	*/
595	using namespace com;
596	HRESULT hrc = com::Initialize();
597	if (FAILED(hrc))
598	{
599	# ifdef VBOX_WITH_XPCOM
600	if (hrc == NS_ERROR_FILE_ACCESS_DENIED)
601	{
602	char szHome[RTPATH_MAX] = "";
603	com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
604	return RTMsgErrorExit(RTEXITCODE_FAILURE,
605	"Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
606	}
607	# endif
608	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM! (hrc=%Rhrc)", hrc);
609	}
610
611
612	/*
613	* Get the remote VirtualBox object and create a local session object.
614	*/
615	rcExit = RTEXITCODE_FAILURE;
616	ComPtr<IVirtualBox> virtualBox;
617	hrc = virtualBox.createLocalObject(CLSID_VirtualBox);
618	if (SUCCEEDED(hrc))
619	{
620	ComPtr<ISession> session;
621	hrc = session.createInprocObject(CLSID_Session);
622	if (SUCCEEDED(hrc))
623	{
624	/* Session secret. */
625	if (pszSettingsPw)
626	CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(Bstr(pszSettingsPw).raw()), rcExit = RTEXITCODE_FAILURE);
627	else if (pszSettingsPwFile)
628	rcExit = settingsPasswordFile(virtualBox, pszSettingsPwFile);
629	else
630	rcExit = RTEXITCODE_SUCCESS;
631	if (rcExit == RTEXITCODE_SUCCESS)
632	{
633	/*
634	* Call the handler.
635	*/
636	HandlerArg handlerArg = { argc - iCmdArg, &argv[iCmdArg], virtualBox, session };
637	rcExit = pCmd->pfnHandler(&handlerArg);
638
639	/* Although all handlers should always close the session if they open it,
640	* we do it here just in case if some of the handlers contains a bug --
641	* leaving the direct session not closed will turn the machine state to
642	* Aborted which may have unwanted side effects like killing the saved
643	* state file (if the machine was in the Saved state before). */
644	session->UnlockMachine();
645	}
646
647	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
648	}
649	else
650	{
651	com::ErrorInfo info;
652	RTMsgError("Failed to create a session object!");
653	if (!info.isFullAvailable() && !info.isBasicAvailable())
654	com::GluePrintRCMessage(hrc);
655	else
656	com::GluePrintErrorInfo(info);
657	}
658	}
659	else
660	{
661	com::ErrorInfo info;
662	RTMsgError("Failed to create the VirtualBox object!");
663	if (!info.isFullAvailable() && !info.isBasicAvailable())
664	{
665	com::GluePrintRCMessage(hrc);
666	RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start.");
667	}
668	else
669	com::GluePrintErrorInfo(info);
670	}
671
672	/*
673	* Terminate COM, make sure the virtualBox object has been released.
674	*/
675	virtualBox.setNull();
676	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
677	com::Shutdown();
678	}
679	else
680	{
681	/*
682	* The command needs no COM.
683	*/
684	HandlerArg handlerArg;
685	handlerArg.argc = argc - iCmdArg;
686	handlerArg.argv = &argv[iCmdArg];
687	rcExit = pCmd->pfnHandler(&handlerArg);
688	}
689
690	return rcExit;
691	#else /* VBOX_ONLY_DOCS */
692	return RTEXITCODE_SUCCESS;
693	#endif /* VBOX_ONLY_DOCS */
694	}

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: