VBoxManage.cpp@ 60865

Last change on this file since 60865 was 60865, checked in by vboxsync, 9 years ago
Never use static instances of CComModule as it messes up the log filename by using VBoxRT.dll before it's initialized.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.1 KB

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

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

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

Download in other formats: