VBoxManage.cpp@ 70582

Last change on this file since 70582 was 70582, checked in by vboxsync, 7 years ago
bugref:8345. First draft of move VM feature. There are some issues but base logic should stay the same. This code hasn't been built on Windows OSes yet.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 28.8 KB

Line
1	/* $Id: VBoxManage.cpp 70582 2018-01-15 10:13:41Z vboxsync $ */
2	/** @file
3	* VBoxManage - VirtualBox's command-line interface.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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/file.h>
41	#include <iprt/getopt.h>
42	#include <iprt/initterm.h>
43	#include <iprt/path.h>
44	#include <iprt/stream.h>
45	#include <iprt/string.h>
46
47	#include <signal.h>
48
49	#include "VBoxManage.h"
50
51
52	/*********************************************************************************************************************************
53	* Defined Constants And Macros *
54	*********************************************************************************************************************************/
55	/** The command doesn't need the COM stuff. */
56	#define VBMG_CMD_F_NO_COM RT_BIT_32(0)
57
58	#define VBMG_CMD_TODO HELP_CMD_VBOXMANAGE_INVALID
59
60
61	/*********************************************************************************************************************************
62	* Structures and Typedefs *
63	*********************************************************************************************************************************/
64	#ifndef VBOX_ONLY_DOCS
65	/**
66	* VBoxManage command descriptor.
67	*/
68	typedef struct VBMGCMD
69	{
70	/** The command. */
71	const char *pszCommand;
72	/** The help category. */
73	USAGECATEGORY enmHelpCat;
74	/** The new help command. */
75	enum HELP_CMD_VBOXMANAGE enmCmdHelp;
76	/** The handler. */
77	RTEXITCODE (pfnHandler)(HandlerArg pArg);
78	/** VBMG_CMD_F_XXX, */
79	uint32_t fFlags;
80	} VBMGCMD;
81	/** Pointer to a const VBoxManage command descriptor. */
82	typedef VBMGCMD const *PCVBMGCMD;
83	#endif
84
85
86	/*********************************************************************************************************************************
87	* Global Variables *
88	*********************************************************************************************************************************/
89	/extern/ bool g_fDetailedProgress = false;
90
91	#ifndef VBOX_ONLY_DOCS
92	/** Set by the signal handler. */
93	static volatile bool g_fCanceled = false;
94
95
96	/**
97	* All registered command handlers
98	*/
99	static const VBMGCMD g_aCommands[] =
100	{
101	{ "internalcommands", 0, VBMG_CMD_TODO, handleInternalCommands, 0 },
102	{ "list", USAGE_LIST, VBMG_CMD_TODO, handleList, 0 },
103	{ "showvminfo", USAGE_SHOWVMINFO, VBMG_CMD_TODO, handleShowVMInfo, 0 },
104	{ "registervm", USAGE_REGISTERVM, VBMG_CMD_TODO, handleRegisterVM, 0 },
105	{ "unregistervm", USAGE_UNREGISTERVM, VBMG_CMD_TODO, handleUnregisterVM, 0 },
106	{ "clonevm", USAGE_CLONEVM, VBMG_CMD_TODO, handleCloneVM, 0 },
107	{ "movevm", USAGE_MOVEVM, VBMG_CMD_TODO, handleMoveVM, 0 },
108	{ "mediumproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 },
109	{ "hdproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, /* backward compatibility */
110	{ "createmedium", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 },
111	{ "createhd", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
112	{ "createvdi", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */
113	{ "modifymedium", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 },
114	{ "modifyhd", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
115	{ "modifyvdi", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */
116	{ "clonemedium", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 },
117	{ "clonehd", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
118	{ "clonevdi", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */
119	{ "encryptmedium", USAGE_ENCRYPTMEDIUM, VBMG_CMD_TODO, handleEncryptMedium, 0 },
120	{ "checkmediumpwd", USAGE_MEDIUMENCCHKPWD, VBMG_CMD_TODO, handleCheckMediumPassword, 0 },
121	{ "createvm", USAGE_CREATEVM, VBMG_CMD_TODO, handleCreateVM, 0 },
122	{ "modifyvm", USAGE_MODIFYVM, VBMG_CMD_TODO, handleModifyVM, 0 },
123	{ "startvm", USAGE_STARTVM, VBMG_CMD_TODO, handleStartVM, 0 },
124	{ "controlvm", USAGE_CONTROLVM, VBMG_CMD_TODO, handleControlVM, 0 },
125	{ "unattended", USAGE_UNATTENDEDINSTALL, HELP_CMD_UNATTENDED, handleUnattended, 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	{ "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	*/
171	static 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	*/
188	static 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	*/
201	HRESULT 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
364	RTEXITCODE 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
403	static 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
415	RTEXITCODE 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
459	int 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.

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

Download in other formats: