VBoxManageMisc.cpp@ 92354

Last change on this file since 92354 was 92143, checked in by vboxsync, 3 years ago
VBoxManage/setproperty/language: Added 32 ms kludge waiting for the main notification about the language change to avoid trouble if we receive it during XPCOM/COM shutdown. bugref:1909
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.7 KB

Line
1	/* $Id: VBoxManageMisc.cpp 92143 2021-10-29 12:52:44Z vboxsync $ */
2	/** @file
3	* VBoxManage - VirtualBox's command-line interface.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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/VirtualBox.h>
30	# include <VBox/com/NativeEventQueue.h>
31	#endif /* !VBOX_ONLY_DOCS */
32
33	#include <iprt/asm.h>
34	#include <iprt/buildconfig.h>
35	#include <iprt/cidr.h>
36	#include <iprt/ctype.h>
37	#include <iprt/dir.h>
38	#include <iprt/env.h>
39	#include <iprt/file.h>
40	#include <iprt/sha.h>
41	#include <iprt/initterm.h>
42	#include <iprt/param.h>
43	#include <iprt/path.h>
44	#include <iprt/cpp/path.h>
45	#include <iprt/stream.h>
46	#include <iprt/string.h>
47	#include <iprt/stdarg.h>
48	#include <iprt/thread.h>
49	#include <iprt/uuid.h>
50	#include <iprt/getopt.h>
51	#include <iprt/ctype.h>
52	#include <VBox/version.h>
53	#include <VBox/log.h>
54
55	#include "VBoxManage.h"
56
57	#include <list>
58
59	using namespace com;
60
61
62
63	RTEXITCODE handleRegisterVM(HandlerArg *a)
64	{
65	HRESULT rc;
66
67	if (a->argc != 1)
68	return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters");
69
70	ComPtr<IMachine> machine;
71	/** @todo Ugly hack to get both the API interpretation of relative paths
72	* and the client's interpretation of relative paths. Remove after the API
73	* has been redesigned. */
74	rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(),
75	machine.asOutParam());
76	if (rc == VBOX_E_FILE_ERROR)
77	{
78	char szVMFileAbs[RTPATH_MAX] = "";
79	int vrc = RTPathAbs(a->argv[0], szVMFileAbs, sizeof(szVMFileAbs));
80	if (RT_FAILURE(vrc))
81	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc);
82	CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs).raw(),
83	machine.asOutParam()));
84	}
85	else if (FAILED(rc))
86	CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]).raw(),
87	machine.asOutParam()));
88	if (SUCCEEDED(rc))
89	{
90	ASSERT(machine);
91	CHECK_ERROR(a->virtualBox, RegisterMachine(machine));
92	}
93	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
94	}
95
96	static const RTGETOPTDEF g_aUnregisterVMOptions[] =
97	{
98	{ "--delete", 'd', RTGETOPT_REQ_NOTHING },
99	{ "-delete", 'd', RTGETOPT_REQ_NOTHING }, // deprecated
100	};
101
102	RTEXITCODE handleUnregisterVM(HandlerArg *a)
103	{
104	HRESULT rc;
105	const char *VMName = NULL;
106	bool fDelete = false;
107
108	int c;
109	RTGETOPTUNION ValueUnion;
110	RTGETOPTSTATE GetState;
111	// start at 0 because main() has hacked both the argc and argv given to us
112	RTGetOptInit(&GetState, a->argc, a->argv, g_aUnregisterVMOptions, RT_ELEMENTS(g_aUnregisterVMOptions),
113	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
114	while ((c = RTGetOpt(&GetState, &ValueUnion)))
115	{
116	switch (c)
117	{
118	case 'd': // --delete
119	fDelete = true;
120	break;
121
122	case VINF_GETOPT_NOT_OPTION:
123	if (!VMName)
124	VMName = ValueUnion.psz;
125	else
126	return errorSyntax(USAGE_UNREGISTERVM, "Invalid parameter '%s'", ValueUnion.psz);
127	break;
128
129	default:
130	if (c > 0)
131	{
132	if (RT_C_IS_PRINT(c))
133	return errorSyntax(USAGE_UNREGISTERVM, "Invalid option -%c", c);
134	return errorSyntax(USAGE_UNREGISTERVM, "Invalid option case %i", c);
135	}
136	if (c == VERR_GETOPT_UNKNOWN_OPTION)
137	return errorSyntax(USAGE_UNREGISTERVM, "unknown option: %s\n", ValueUnion.psz);
138	if (ValueUnion.pDef)
139	return errorSyntax(USAGE_UNREGISTERVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
140	return errorSyntax(USAGE_UNREGISTERVM, "error: %Rrs", c);
141	}
142	}
143
144	/* check for required options */
145	if (!VMName)
146	return errorSyntax(USAGE_UNREGISTERVM, "VM name required");
147
148	ComPtr<IMachine> machine;
149	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(VMName).raw(),
150	machine.asOutParam()),
151	RTEXITCODE_FAILURE);
152	SafeIfaceArray<IMedium> aMedia;
153	CHECK_ERROR_RET(machine, Unregister(CleanupMode_DetachAllReturnHardDisksOnly,
154	ComSafeArrayAsOutParam(aMedia)),
155	RTEXITCODE_FAILURE);
156	if (fDelete)
157	{
158	ComPtr<IProgress> pProgress;
159	CHECK_ERROR_RET(machine, DeleteConfig(ComSafeArrayAsInParam(aMedia), pProgress.asOutParam()),
160	RTEXITCODE_FAILURE);
161
162	rc = showProgress(pProgress);
163	CHECK_PROGRESS_ERROR_RET(pProgress, ("Machine delete failed"), RTEXITCODE_FAILURE);
164	}
165	else
166	{
167	/* Note that the IMachine::Unregister method will return the medium
168	* reference in a sane order, which means that closing will normally
169	* succeed, unless there is still another machine which uses the
170	* medium. No harm done if we ignore the error. */
171	for (size_t i = 0; i < aMedia.size(); i++)
172	{
173	IMedium *pMedium = aMedia[i];
174	if (pMedium)
175	rc = pMedium->Close();
176	}
177	rc = S_OK;
178	}
179	return RTEXITCODE_SUCCESS;
180	}
181
182	static const RTGETOPTDEF g_aCreateVMOptions[] =
183	{
184	{ "--name", 'n', RTGETOPT_REQ_STRING },
185	{ "-name", 'n', RTGETOPT_REQ_STRING },
186	{ "--groups", 'g', RTGETOPT_REQ_STRING },
187	{ "--basefolder", 'p', RTGETOPT_REQ_STRING },
188	{ "-basefolder", 'p', RTGETOPT_REQ_STRING },
189	{ "--ostype", 'o', RTGETOPT_REQ_STRING },
190	{ "-ostype", 'o', RTGETOPT_REQ_STRING },
191	{ "--uuid", 'u', RTGETOPT_REQ_UUID },
192	{ "-uuid", 'u', RTGETOPT_REQ_UUID },
193	{ "--register", 'r', RTGETOPT_REQ_NOTHING },
194	{ "-register", 'r', RTGETOPT_REQ_NOTHING },
195	{ "--default", 'd', RTGETOPT_REQ_NOTHING },
196	{ "-default", 'd', RTGETOPT_REQ_NOTHING },
197	};
198
199	RTEXITCODE handleCreateVM(HandlerArg *a)
200	{
201	HRESULT rc;
202	Bstr bstrBaseFolder;
203	Bstr bstrName;
204	Bstr bstrOsTypeId;
205	Bstr bstrUuid;
206	bool fRegister = false;
207	bool fDefault = false;
208	/* TBD. Now not used */
209	Bstr bstrDefaultFlags;
210	com::SafeArray<BSTR> groups;
211
212	int c;
213	RTGETOPTUNION ValueUnion;
214	RTGETOPTSTATE GetState;
215	// start at 0 because main() has hacked both the argc and argv given to us
216	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateVMOptions, RT_ELEMENTS(g_aCreateVMOptions),
217	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
218	while ((c = RTGetOpt(&GetState, &ValueUnion)))
219	{
220	switch (c)
221	{
222	case 'n': // --name
223	bstrName = ValueUnion.psz;
224	break;
225
226	case 'g': // --groups
227	parseGroups(ValueUnion.psz, &groups);
228	break;
229
230	case 'p': // --basefolder
231	bstrBaseFolder = ValueUnion.psz;
232	break;
233
234	case 'o': // --ostype
235	bstrOsTypeId = ValueUnion.psz;
236	break;
237
238	case 'u': // --uuid
239	bstrUuid = Guid(ValueUnion.Uuid).toUtf16().raw();
240	break;
241
242	case 'r': // --register
243	fRegister = true;
244	break;
245
246	case 'd': // --default
247	fDefault = true;
248	break;
249
250	default:
251	return errorGetOpt(USAGE_CREATEVM, c, &ValueUnion);
252	}
253	}
254
255	/* check for required options */
256	if (bstrName.isEmpty())
257	return errorSyntax(USAGE_CREATEVM, "Parameter --name is required");
258
259	do
260	{
261	Bstr createFlags;
262	if (!bstrUuid.isEmpty())
263	createFlags = BstrFmt("UUID=%ls", bstrUuid.raw());
264	Bstr bstrPrimaryGroup;
265	if (groups.size())
266	bstrPrimaryGroup = groups[0];
267	Bstr bstrSettingsFile;
268	CHECK_ERROR_BREAK(a->virtualBox,
269	ComposeMachineFilename(bstrName.raw(),
270	bstrPrimaryGroup.raw(),
271	createFlags.raw(),
272	bstrBaseFolder.raw(),
273	bstrSettingsFile.asOutParam()));
274	ComPtr<IMachine> machine;
275	CHECK_ERROR_BREAK(a->virtualBox,
276	CreateMachine(bstrSettingsFile.raw(),
277	bstrName.raw(),
278	ComSafeArrayAsInParam(groups),
279	bstrOsTypeId.raw(),
280	createFlags.raw(),
281	machine.asOutParam()));
282
283	CHECK_ERROR_BREAK(machine, SaveSettings());
284	if (fDefault)
285	{
286	/* ApplyDefaults assumes the machine is already registered */
287	CHECK_ERROR_BREAK(machine, ApplyDefaults(bstrDefaultFlags.raw()));
288	CHECK_ERROR_BREAK(machine, SaveSettings());
289	}
290	if (fRegister)
291	{
292	CHECK_ERROR_BREAK(a->virtualBox, RegisterMachine(machine));
293	}
294
295	Bstr uuid;
296	CHECK_ERROR_BREAK(machine, COMGETTER(Id)(uuid.asOutParam()));
297	Bstr settingsFile;
298	CHECK_ERROR_BREAK(machine, COMGETTER(SettingsFilePath)(settingsFile.asOutParam()));
299	RTPrintf("Virtual machine '%ls' is created%s.\n"
300	"UUID: %s\n"
301	"Settings file: '%ls'\n",
302	bstrName.raw(), fRegister ? " and registered" : "",
303	Utf8Str(uuid).c_str(), settingsFile.raw());
304	}
305	while (0);
306
307	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
308	}
309
310	static const RTGETOPTDEF g_aMoveVMOptions[] =
311	{
312	{ "--type", 't', RTGETOPT_REQ_STRING },
313	{ "--folder", 'f', RTGETOPT_REQ_STRING },
314	};
315
316	RTEXITCODE handleMoveVM(HandlerArg *a)
317	{
318	HRESULT rc;
319	const char *pszSrcName = NULL;
320	const char *pszType = NULL;
321	char szTargetFolder[RTPATH_MAX];
322
323	int c;
324	int vrc = VINF_SUCCESS;
325	RTGETOPTUNION ValueUnion;
326	RTGETOPTSTATE GetState;
327
328	// start at 0 because main() has hacked both the argc and argv given to us
329	RTGetOptInit(&GetState, a->argc, a->argv, g_aMoveVMOptions, RT_ELEMENTS(g_aMoveVMOptions),
330	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
331	while ((c = RTGetOpt(&GetState, &ValueUnion)))
332	{
333	switch (c)
334	{
335	case 't': // --type
336	pszType = ValueUnion.psz;
337	break;
338
339	case 'f': // --target folder
340	if (ValueUnion.psz && ValueUnion.psz[0] != '\0')
341	{
342	vrc = RTPathAbs(ValueUnion.psz, szTargetFolder, sizeof(szTargetFolder));
343	if (RT_FAILURE(vrc))
344	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", ValueUnion.psz, vrc);
345	} else {
346	szTargetFolder[0] = '\0';
347	}
348	break;
349
350	case VINF_GETOPT_NOT_OPTION:
351	if (!pszSrcName)
352	pszSrcName = ValueUnion.psz;
353	else
354	return errorSyntax(USAGE_MOVEVM, "Invalid parameter '%s'", ValueUnion.psz);
355	break;
356
357	default:
358	return errorGetOpt(USAGE_MOVEVM, c, &ValueUnion);
359	}
360	}
361
362
363	if (!pszType)
364	{
365	pszType = "basic";
366	}
367
368	/* Check for required options */
369	if (!pszSrcName)
370	return errorSyntax(USAGE_MOVEVM, "VM name required");
371
372	/* Get the machine object */
373	ComPtr<IMachine> srcMachine;
374	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(pszSrcName).raw(),
375	srcMachine.asOutParam()),
376	RTEXITCODE_FAILURE);
377
378	if (srcMachine)
379	{
380	/* Start the moving */
381	ComPtr<IProgress> progress;
382
383	/* we have to open a session for this task */
384	CHECK_ERROR_RET(srcMachine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
385	ComPtr<IMachine> sessionMachine;
386
387	CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
388	CHECK_ERROR_RET(sessionMachine,
389	MoveTo(Bstr(szTargetFolder).raw(),
390	Bstr(pszType).raw(),
391	progress.asOutParam()),
392	RTEXITCODE_FAILURE);
393	rc = showProgress(progress);
394	CHECK_PROGRESS_ERROR_RET(progress, ("Move VM failed"), RTEXITCODE_FAILURE);
395
396	sessionMachine.setNull();
397	CHECK_ERROR_RET(a->session, UnlockMachine(), RTEXITCODE_FAILURE);
398
399	RTPrintf("Machine has been successfully moved into %s\n", szTargetFolder[0] != '\0' ? szTargetFolder : "the same location");
400	}
401
402	return RTEXITCODE_SUCCESS;
403	}
404
405	static const RTGETOPTDEF g_aCloneVMOptions[] =
406	{
407	{ "--snapshot", 's', RTGETOPT_REQ_STRING },
408	{ "--name", 'n', RTGETOPT_REQ_STRING },
409	{ "--groups", 'g', RTGETOPT_REQ_STRING },
410	{ "--mode", 'm', RTGETOPT_REQ_STRING },
411	{ "--options", 'o', RTGETOPT_REQ_STRING },
412	{ "--register", 'r', RTGETOPT_REQ_NOTHING },
413	{ "--basefolder", 'p', RTGETOPT_REQ_STRING },
414	{ "--uuid", 'u', RTGETOPT_REQ_UUID },
415	};
416
417	static int parseCloneMode(const char psz, CloneMode_T pMode)
418	{
419	if (!RTStrICmp(psz, "machine"))
420	*pMode = CloneMode_MachineState;
421	else if (!RTStrICmp(psz, "machineandchildren"))
422	*pMode = CloneMode_MachineAndChildStates;
423	else if (!RTStrICmp(psz, "all"))
424	*pMode = CloneMode_AllStates;
425	else
426	return VERR_PARSE_ERROR;
427
428	return VINF_SUCCESS;
429	}
430
431	static int parseCloneOptions(const char psz, com::SafeArray<CloneOptions_T> options)
432	{
433	int rc = VINF_SUCCESS;
434	while (psz && *psz && RT_SUCCESS(rc))
435	{
436	size_t len;
437	const char *pszComma = strchr(psz, ',');
438	if (pszComma)
439	len = pszComma - psz;
440	else
441	len = strlen(psz);
442	if (len > 0)
443	{
444	if (!RTStrNICmp(psz, "KeepAllMACs", len))
445	options->push_back(CloneOptions_KeepAllMACs);
446	else if (!RTStrNICmp(psz, "KeepNATMACs", len))
447	options->push_back(CloneOptions_KeepNATMACs);
448	else if (!RTStrNICmp(psz, "KeepDiskNames", len))
449	options->push_back(CloneOptions_KeepDiskNames);
450	else if ( !RTStrNICmp(psz, "Link", len)
451	\|\| !RTStrNICmp(psz, "Linked", len))
452	options->push_back(CloneOptions_Link);
453	else if ( !RTStrNICmp(psz, "KeepHwUUIDs", len)
454	\|\| !RTStrNICmp(psz, "KeepHwUUID", len))
455	options->push_back(CloneOptions_KeepHwUUIDs);
456	else
457	rc = VERR_PARSE_ERROR;
458	}
459	if (pszComma)
460	psz += len + 1;
461	else
462	psz += len;
463	}
464
465	return rc;
466	}
467
468	RTEXITCODE handleCloneVM(HandlerArg *a)
469	{
470	HRESULT rc;
471	const char *pszSrcName = NULL;
472	const char *pszSnapshotName = NULL;
473	CloneMode_T mode = CloneMode_MachineState;
474	com::SafeArray<CloneOptions_T> options;
475	const char *pszTrgName = NULL;
476	const char *pszTrgBaseFolder = NULL;
477	bool fRegister = false;
478	Bstr bstrUuid;
479	com::SafeArray<BSTR> groups;
480
481	int c;
482	RTGETOPTUNION ValueUnion;
483	RTGETOPTSTATE GetState;
484	// start at 0 because main() has hacked both the argc and argv given to us
485	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneVMOptions, RT_ELEMENTS(g_aCloneVMOptions),
486	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
487	while ((c = RTGetOpt(&GetState, &ValueUnion)))
488	{
489	switch (c)
490	{
491	case 's': // --snapshot
492	pszSnapshotName = ValueUnion.psz;
493	break;
494
495	case 'n': // --name
496	pszTrgName = ValueUnion.psz;
497	break;
498
499	case 'g': // --groups
500	parseGroups(ValueUnion.psz, &groups);
501	break;
502
503	case 'p': // --basefolder
504	pszTrgBaseFolder = ValueUnion.psz;
505	break;
506
507	case 'm': // --mode
508	if (RT_FAILURE(parseCloneMode(ValueUnion.psz, &mode)))
509	return errorArgument("Invalid clone mode '%s'\n", ValueUnion.psz);
510	break;
511
512	case 'o': // --options
513	if (RT_FAILURE(parseCloneOptions(ValueUnion.psz, &options)))
514	return errorArgument("Invalid clone options '%s'\n", ValueUnion.psz);
515	break;
516
517	case 'u': // --uuid
518	bstrUuid = Guid(ValueUnion.Uuid).toUtf16().raw();
519	break;
520
521	case 'r': // --register
522	fRegister = true;
523	break;
524
525	case VINF_GETOPT_NOT_OPTION:
526	if (!pszSrcName)
527	pszSrcName = ValueUnion.psz;
528	else
529	return errorSyntax("Invalid parameter '%s'", ValueUnion.psz);
530	break;
531
532	default:
533	return errorGetOpt(c, &ValueUnion);
534	}
535	}
536
537	/* Check for required options */
538	if (!pszSrcName)
539	return errorSyntax("VM name required");
540
541	/* Get the machine object */
542	ComPtr<IMachine> srcMachine;
543	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(pszSrcName).raw(),
544	srcMachine.asOutParam()),
545	RTEXITCODE_FAILURE);
546
547	/* If a snapshot name/uuid was given, get the particular machine of this
548	* snapshot. */
549	if (pszSnapshotName)
550	{
551	ComPtr<ISnapshot> srcSnapshot;
552	CHECK_ERROR_RET(srcMachine, FindSnapshot(Bstr(pszSnapshotName).raw(),
553	srcSnapshot.asOutParam()),
554	RTEXITCODE_FAILURE);
555	CHECK_ERROR_RET(srcSnapshot, COMGETTER(Machine)(srcMachine.asOutParam()),
556	RTEXITCODE_FAILURE);
557	}
558
559	/* Default name necessary? */
560	if (!pszTrgName)
561	pszTrgName = RTStrAPrintf2("%s Clone", pszSrcName);
562
563	Bstr createFlags;
564	if (!bstrUuid.isEmpty())
565	createFlags = BstrFmt("UUID=%ls", bstrUuid.raw());
566	Bstr bstrPrimaryGroup;
567	if (groups.size())
568	bstrPrimaryGroup = groups[0];
569	Bstr bstrSettingsFile;
570	CHECK_ERROR_RET(a->virtualBox,
571	ComposeMachineFilename(Bstr(pszTrgName).raw(),
572	bstrPrimaryGroup.raw(),
573	createFlags.raw(),
574	Bstr(pszTrgBaseFolder).raw(),
575	bstrSettingsFile.asOutParam()),
576	RTEXITCODE_FAILURE);
577
578	ComPtr<IMachine> trgMachine;
579	CHECK_ERROR_RET(a->virtualBox, CreateMachine(bstrSettingsFile.raw(),
580	Bstr(pszTrgName).raw(),
581	ComSafeArrayAsInParam(groups),
582	NULL,
583	createFlags.raw(),
584	trgMachine.asOutParam()),
585	RTEXITCODE_FAILURE);
586
587	/* Start the cloning */
588	ComPtr<IProgress> progress;
589	CHECK_ERROR_RET(srcMachine, CloneTo(trgMachine,
590	mode,
591	ComSafeArrayAsInParam(options),
592	progress.asOutParam()),
593	RTEXITCODE_FAILURE);
594	rc = showProgress(progress);
595	CHECK_PROGRESS_ERROR_RET(progress, ("Clone VM failed"), RTEXITCODE_FAILURE);
596
597	if (fRegister)
598	CHECK_ERROR_RET(a->virtualBox, RegisterMachine(trgMachine), RTEXITCODE_FAILURE);
599
600	Bstr bstrNewName;
601	CHECK_ERROR_RET(trgMachine, COMGETTER(Name)(bstrNewName.asOutParam()), RTEXITCODE_FAILURE);
602	RTPrintf("Machine has been successfully cloned as \"%ls\"\n", bstrNewName.raw());
603
604	return RTEXITCODE_SUCCESS;
605	}
606
607	RTEXITCODE handleStartVM(HandlerArg *a)
608	{
609	HRESULT rc = S_OK;
610	std::list<const char *> VMs;
611	Bstr sessionType;
612	com::SafeArray<IN_BSTR> aBstrEnv;
613
614	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS)
615	/* make sure the VM process will by default start on the same display as VBoxManage */
616	{
617	const char *pszDisplay = RTEnvGet("DISPLAY");
618	if (pszDisplay)
619	aBstrEnv.push_back(BstrFmt("DISPLAY=%s", pszDisplay).raw());
620	const char *pszXAuth = RTEnvGet("XAUTHORITY");
621	if (pszXAuth)
622	aBstrEnv.push_back(BstrFmt("XAUTHORITY=%s", pszXAuth).raw());
623	}
624	#endif
625
626	static const RTGETOPTDEF s_aStartVMOptions[] =
627	{
628	{ "--type", 't', RTGETOPT_REQ_STRING },
629	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
630	{ "--putenv", 'E', RTGETOPT_REQ_STRING },
631	};
632	int c;
633	RTGETOPTUNION ValueUnion;
634	RTGETOPTSTATE GetState;
635	// start at 0 because main() has hacked both the argc and argv given to us
636	RTGetOptInit(&GetState, a->argc, a->argv, s_aStartVMOptions, RT_ELEMENTS(s_aStartVMOptions),
637	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
638	while ((c = RTGetOpt(&GetState, &ValueUnion)))
639	{
640	switch (c)
641	{
642	case 't': // --type
643	if (!RTStrICmp(ValueUnion.psz, "gui"))
644	{
645	sessionType = "gui";
646	}
647	#ifdef VBOX_WITH_VBOXSDL
648	else if (!RTStrICmp(ValueUnion.psz, "sdl"))
649	{
650	sessionType = "sdl";
651	}
652	#endif
653	#ifdef VBOX_WITH_HEADLESS
654	else if (!RTStrICmp(ValueUnion.psz, "capture"))
655	{
656	sessionType = "capture";
657	}
658	else if (!RTStrICmp(ValueUnion.psz, "headless"))
659	{
660	sessionType = "headless";
661	}
662	#endif
663	else
664	sessionType = ValueUnion.psz;
665	break;
666
667	case 'E': // --putenv
668	if (!RTStrStr(ValueUnion.psz, "\n"))
669	aBstrEnv.push_back(Bstr(ValueUnion.psz).raw());
670	else
671	return errorSyntax(USAGE_STARTVM, "Parameter to option --putenv must not contain any newline character");
672	break;
673
674	case VINF_GETOPT_NOT_OPTION:
675	VMs.push_back(ValueUnion.psz);
676	break;
677
678	default:
679	if (c > 0)
680	{
681	if (RT_C_IS_PRINT(c))
682	return errorSyntax(USAGE_STARTVM, "Invalid option -%c", c);
683	else
684	return errorSyntax(USAGE_STARTVM, "Invalid option case %i", c);
685	}
686	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
687	return errorSyntax(USAGE_STARTVM, "unknown option: %s\n", ValueUnion.psz);
688	else if (ValueUnion.pDef)
689	return errorSyntax(USAGE_STARTVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
690	else
691	return errorSyntax(USAGE_STARTVM, "error: %Rrs", c);
692	}
693	}
694
695	/* check for required options */
696	if (VMs.empty())
697	return errorSyntax(USAGE_STARTVM, "at least one VM name or uuid required");
698
699	for (std::list<const char *>::const_iterator it = VMs.begin();
700	it != VMs.end();
701	++it)
702	{
703	HRESULT rc2 = rc;
704	const char pszVM = it;
705	ComPtr<IMachine> machine;
706	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(pszVM).raw(),
707	machine.asOutParam()));
708	if (machine)
709	{
710	ComPtr<IProgress> progress;
711	CHECK_ERROR(machine, LaunchVMProcess(a->session, sessionType.raw(),
712	ComSafeArrayAsInParam(aBstrEnv), progress.asOutParam()));
713	if (SUCCEEDED(rc) && !progress.isNull())
714	{
715	RTPrintf("Waiting for VM \"%s\" to power on...\n", pszVM);
716	CHECK_ERROR(progress, WaitForCompletion(-1));
717	if (SUCCEEDED(rc))
718	{
719	BOOL completed = true;
720	CHECK_ERROR(progress, COMGETTER(Completed)(&completed));
721	if (SUCCEEDED(rc))
722	{
723	ASSERT(completed);
724
725	LONG iRc;
726	CHECK_ERROR(progress, COMGETTER(ResultCode)(&iRc));
727	if (SUCCEEDED(rc))
728	{
729	if (SUCCEEDED(iRc))
730	RTPrintf("VM \"%s\" has been successfully started.\n", pszVM);
731	else
732	{
733	ProgressErrorInfo info(progress);
734	com::GluePrintErrorInfo(info);
735	}
736	rc = iRc;
737	}
738	}
739	}
740	}
741	}
742
743	/* it's important to always close sessions */
744	a->session->UnlockMachine();
745
746	/* make sure that we remember the failed state */
747	if (FAILED(rc2))
748	rc = rc2;
749	}
750
751	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
752	}
753
754	RTEXITCODE handleDiscardState(HandlerArg *a)
755	{
756	HRESULT rc;
757
758	if (a->argc != 1)
759	return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters");
760
761	ComPtr<IMachine> machine;
762	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
763	machine.asOutParam()));
764	if (machine)
765	{
766	do
767	{
768	/* we have to open a session for this task */
769	CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write));
770	do
771	{
772	ComPtr<IMachine> sessionMachine;
773	CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()));
774	CHECK_ERROR_BREAK(sessionMachine, DiscardSavedState(true /* fDeleteFile */));
775	} while (0);
776	CHECK_ERROR_BREAK(a->session, UnlockMachine());
777	} while (0);
778	}
779
780	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
781	}
782
783	RTEXITCODE handleAdoptState(HandlerArg *a)
784	{
785	HRESULT rc;
786
787	if (a->argc != 2)
788	return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters");
789
790	ComPtr<IMachine> machine;
791	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
792	machine.asOutParam()));
793	if (machine)
794	{
795	char szStateFileAbs[RTPATH_MAX] = "";
796	int vrc = RTPathAbs(a->argv[1], szStateFileAbs, sizeof(szStateFileAbs));
797	if (RT_FAILURE(vrc))
798	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc);
799
800	do
801	{
802	/* we have to open a session for this task */
803	CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write));
804	do
805	{
806	ComPtr<IMachine> sessionMachine;
807	CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()));
808	CHECK_ERROR_BREAK(sessionMachine, AdoptSavedState(Bstr(szStateFileAbs).raw()));
809	} while (0);
810	CHECK_ERROR_BREAK(a->session, UnlockMachine());
811	} while (0);
812	}
813
814	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
815	}
816
817	RTEXITCODE handleGetExtraData(HandlerArg *a)
818	{
819	HRESULT rc = S_OK;
820
821	if (a->argc > 2 \|\| a->argc < 1)
822	return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");
823
824	/* global data? */
825	if (!strcmp(a->argv[0], "global"))
826	{
827	/* enumeration? */
828	if (a->argc < 2 \|\| !strcmp(a->argv[1], "enumerate"))
829	{
830	SafeArray<BSTR> aKeys;
831	CHECK_ERROR(a->virtualBox, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
832
833	for (size_t i = 0;
834	i < aKeys.size();
835	++i)
836	{
837	Bstr bstrKey(aKeys[i]);
838	Bstr bstrValue;
839	CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey.raw(),
840	bstrValue.asOutParam()));
841
842	RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
843	}
844	}
845	else
846	{
847	Bstr value;
848	CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]).raw(),
849	value.asOutParam()));
850	if (!value.isEmpty())
851	RTPrintf("Value: %ls\n", value.raw());
852	else
853	RTPrintf("No value set!\n");
854	}
855	}
856	else
857	{
858	ComPtr<IMachine> machine;
859	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
860	machine.asOutParam()));
861	if (machine)
862	{
863	/* enumeration? */
864	if (a->argc < 2 \|\| !strcmp(a->argv[1], "enumerate"))
865	{
866	SafeArray<BSTR> aKeys;
867	CHECK_ERROR(machine, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
868
869	for (size_t i = 0;
870	i < aKeys.size();
871	++i)
872	{
873	Bstr bstrKey(aKeys[i]);
874	Bstr bstrValue;
875	CHECK_ERROR(machine, GetExtraData(bstrKey.raw(),
876	bstrValue.asOutParam()));
877
878	RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw());
879	}
880	}
881	else
882	{
883	Bstr value;
884	CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]).raw(),
885	value.asOutParam()));
886	if (!value.isEmpty())
887	RTPrintf("Value: %ls\n", value.raw());
888	else
889	RTPrintf("No value set!\n");
890	}
891	}
892	}
893	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
894	}
895
896	RTEXITCODE handleSetExtraData(HandlerArg *a)
897	{
898	HRESULT rc = S_OK;
899
900	if (a->argc < 2)
901	return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters");
902
903	/* global data? */
904	if (!strcmp(a->argv[0], "global"))
905	{
906	/** @todo passing NULL is deprecated */
907	if (a->argc < 3)
908	CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),
909	NULL));
910	else if (a->argc == 3)
911	CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(),
912	Bstr(a->argv[2]).raw()));
913	else
914	return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
915	}
916	else
917	{
918	ComPtr<IMachine> machine;
919	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
920	machine.asOutParam()));
921	if (machine)
922	{
923	/* open an existing session for the VM */
924	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
925	/* get the session machine */
926	ComPtr<IMachine> sessionMachine;
927	CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
928	/** @todo passing NULL is deprecated */
929	if (a->argc < 3)
930	CHECK_ERROR(sessionMachine, SetExtraData(Bstr(a->argv[1]).raw(),
931	NULL));
932	else if (a->argc == 3)
933	CHECK_ERROR(sessionMachine, SetExtraData(Bstr(a->argv[1]).raw(),
934	Bstr(a->argv[2]).raw()));
935	else
936	return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
937	}
938	}
939	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
940	}
941
942	RTEXITCODE handleSetProperty(HandlerArg *a)
943	{
944	HRESULT rc;
945
946	/* there must be two arguments: property name and value */
947	if (a->argc != 2)
948	return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters");
949
950	ComPtr<ISystemProperties> systemProperties;
951	a->virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
952
953	if (!strcmp(a->argv[0], "machinefolder"))
954	{
955	/* reset to default? */
956	if (!strcmp(a->argv[1], "default"))
957	CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(NULL));
958	else
959	CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(a->argv[1]).raw()));
960	}
961	else if (!strcmp(a->argv[0], "hwvirtexclusive"))
962	{
963	bool fHwVirtExclusive;
964
965	if (!strcmp(a->argv[1], "on"))
966	fHwVirtExclusive = true;
967	else if (!strcmp(a->argv[1], "off"))
968	fHwVirtExclusive = false;
969	else
970	return errorArgument("Invalid hwvirtexclusive argument '%s'", a->argv[1]);
971	CHECK_ERROR(systemProperties, COMSETTER(ExclusiveHwVirt)(fHwVirtExclusive));
972	}
973	else if ( !strcmp(a->argv[0], "vrdeauthlibrary")
974	\|\| !strcmp(a->argv[0], "vrdpauthlibrary"))
975	{
976	if (!strcmp(a->argv[0], "vrdpauthlibrary"))
977	RTStrmPrintf(g_pStdErr, "Warning: 'vrdpauthlibrary' is deprecated. Use 'vrdeauthlibrary'.\n");
978
979	/* reset to default? */
980	if (!strcmp(a->argv[1], "default"))
981	CHECK_ERROR(systemProperties, COMSETTER(VRDEAuthLibrary)(NULL));
982	else
983	CHECK_ERROR(systemProperties, COMSETTER(VRDEAuthLibrary)(Bstr(a->argv[1]).raw()));
984	}
985	else if (!strcmp(a->argv[0], "websrvauthlibrary"))
986	{
987	/* reset to default? */
988	if (!strcmp(a->argv[1], "default"))
989	CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(NULL));
990	else
991	CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(a->argv[1]).raw()));
992	}
993	else if (!strcmp(a->argv[0], "vrdeextpack"))
994	{
995	/* disable? */
996	if (!strcmp(a->argv[1], "null"))
997	CHECK_ERROR(systemProperties, COMSETTER(DefaultVRDEExtPack)(NULL));
998	else
999	CHECK_ERROR(systemProperties, COMSETTER(DefaultVRDEExtPack)(Bstr(a->argv[1]).raw()));
1000	}
1001	else if (!strcmp(a->argv[0], "loghistorycount"))
1002	{
1003	uint32_t uVal;
1004	int vrc;
1005	vrc = RTStrToUInt32Ex(a->argv[1], NULL, 0, &uVal);
1006	if (vrc != VINF_SUCCESS)
1007	return errorArgument("Error parsing Log history count '%s'", a->argv[1]);
1008	CHECK_ERROR(systemProperties, COMSETTER(LogHistoryCount)(uVal));
1009	}
1010	else if (!strcmp(a->argv[0], "autostartdbpath"))
1011	{
1012	/* disable? */
1013	if (!strcmp(a->argv[1], "null"))
1014	CHECK_ERROR(systemProperties, COMSETTER(AutostartDatabasePath)(NULL));
1015	else
1016	CHECK_ERROR(systemProperties, COMSETTER(AutostartDatabasePath)(Bstr(a->argv[1]).raw()));
1017	}
1018	else if (!strcmp(a->argv[0], "defaultfrontend"))
1019	{
1020	Bstr bstrDefaultFrontend(a->argv[1]);
1021	if (!strcmp(a->argv[1], "default"))
1022	bstrDefaultFrontend.setNull();
1023	CHECK_ERROR(systemProperties, COMSETTER(DefaultFrontend)(bstrDefaultFrontend.raw()));
1024	}
1025	else if (!strcmp(a->argv[0], "logginglevel"))
1026	{
1027	Bstr bstrLoggingLevel(a->argv[1]);
1028	if (!strcmp(a->argv[1], "default"))
1029	bstrLoggingLevel.setNull();
1030	CHECK_ERROR(systemProperties, COMSETTER(LoggingLevel)(bstrLoggingLevel.raw()));
1031	}
1032	else if (!strcmp(a->argv[0], "proxymode"))
1033	{
1034	ProxyMode_T enmProxyMode;
1035	if (!RTStrICmpAscii(a->argv[1], "system"))
1036	enmProxyMode = ProxyMode_System;
1037	else if (!RTStrICmpAscii(a->argv[1], "noproxy"))
1038	enmProxyMode = ProxyMode_NoProxy;
1039	else if (!RTStrICmpAscii(a->argv[1], "manual"))
1040	enmProxyMode = ProxyMode_Manual;
1041	else
1042	return errorArgument("Unknown proxy mode: '%s'", a->argv[1]);
1043	CHECK_ERROR(systemProperties, COMSETTER(ProxyMode)(enmProxyMode));
1044	}
1045	else if (!strcmp(a->argv[0], "proxyurl"))
1046	{
1047	Bstr bstrProxyUrl(a->argv[1]);
1048	CHECK_ERROR(systemProperties, COMSETTER(ProxyURL)(bstrProxyUrl.raw()));
1049	}
1050	#ifdef VBOX_WITH_MAIN_NLS
1051	else if (!strcmp(a->argv[0], "language"))
1052	{
1053	Bstr bstrLanguage(a->argv[1]);
1054	CHECK_ERROR(systemProperties, COMSETTER(LanguageId)(bstrLanguage.raw()));
1055
1056	/* Kudge alert! Make sure the language change notification is processed,
1057	otherwise it may arrive as (XP)COM shuts down and cause
1058	trouble in debug builds. */
1059	# ifdef DEBUG
1060	uint64_t const tsStart = RTTimeNanoTS();
1061	# endif
1062	unsigned cMsgs = 0;
1063	int vrc;
1064	while ( RT_SUCCESS(vrc = NativeEventQueue::getMainEventQueue()->processEventQueue(32 /ms/))
1065	\|\| vrc == VERR_INTERRUPTED)
1066	cMsgs++;
1067	# ifdef DEBUG
1068	RTPrintf("vrc=%Rrc cMsgs=%u nsElapsed=%'RU64\n", vrc, cMsgs, RTTimeNanoTS() - tsStart);
1069	# endif
1070	}
1071	#endif
1072	else
1073	return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", a->argv[0]);
1074
1075	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1076	}
1077
1078	/**
1079	* sharedfolder add
1080	*/
1081	static RTEXITCODE handleSharedFolderAdd(HandlerArg *a)
1082	{
1083	/*
1084	* Parse arguments (argv[0] == subcommand).
1085	*/
1086	static const RTGETOPTDEF s_aAddOptions[] =
1087	{
1088	{ "--name", 'n', RTGETOPT_REQ_STRING },
1089	{ "-name", 'n', RTGETOPT_REQ_STRING }, // deprecated
1090	{ "--hostpath", 'p', RTGETOPT_REQ_STRING },
1091	{ "-hostpath", 'p', RTGETOPT_REQ_STRING }, // deprecated
1092	{ "--readonly", 'r', RTGETOPT_REQ_NOTHING },
1093	{ "-readonly", 'r', RTGETOPT_REQ_NOTHING }, // deprecated
1094	{ "--transient", 't', RTGETOPT_REQ_NOTHING },
1095	{ "-transient", 't', RTGETOPT_REQ_NOTHING }, // deprecated
1096	{ "--automount", 'a', RTGETOPT_REQ_NOTHING },
1097	{ "-automount", 'a', RTGETOPT_REQ_NOTHING }, // deprecated
1098	{ "--auto-mount-point", 'm', RTGETOPT_REQ_STRING },
1099	};
1100	const char *pszMachineName = NULL;
1101	const char *pszName = NULL;
1102	const char *pszHostPath = NULL;
1103	bool fTransient = false;
1104	bool fWritable = true;
1105	bool fAutoMount = false;
1106	const char *pszAutoMountPoint = "";
1107
1108	RTGETOPTSTATE GetState;
1109	RTGetOptInit(&GetState, a->argc, a->argv, s_aAddOptions, RT_ELEMENTS(s_aAddOptions), 1 /iFirst/, 0 /fFlags/);
1110	int c;
1111	RTGETOPTUNION ValueUnion;
1112	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1113	{
1114	switch (c)
1115	{
1116	case 'n':
1117	pszName = ValueUnion.psz;
1118	break;
1119	case 'p':
1120	pszHostPath = ValueUnion.psz;
1121	break;
1122	case 'r':
1123	fWritable = false;
1124	break;
1125	case 't':
1126	fTransient = true;
1127	break;
1128	case 'a':
1129	fAutoMount = true;
1130	break;
1131	case 'm':
1132	pszAutoMountPoint = ValueUnion.psz;
1133	break;
1134	case VINF_GETOPT_NOT_OPTION:
1135	if (pszMachineName)
1136	return errorArgument("Machine name is given more than once: first '%s', then '%s'",
1137	pszMachineName, ValueUnion.psz);
1138	pszMachineName = ValueUnion.psz;
1139	break;
1140	default:
1141	return errorGetOpt(c, &ValueUnion);
1142	}
1143	}
1144
1145	if (!pszMachineName)
1146	return errorSyntax("No machine was specified");
1147
1148	if (!pszName)
1149	return errorSyntax("No shared folder name (--name) was given");
1150	if (strchr(pszName, ' '))
1151	return errorSyntax("Invalid shared folder name '%s': contains space", pszName);
1152	if (strchr(pszName, '\t'))
1153	return errorSyntax("Invalid shared folder name '%s': contains tabs", pszName);
1154	if (strchr(pszName, '\n') \|\| strchr(pszName, '\r'))
1155	return errorSyntax("Invalid shared folder name '%s': contains newline", pszName);
1156
1157	if (!pszHostPath)
1158	return errorSyntax("No host path (--hostpath) was given");
1159	char szAbsHostPath[RTPATH_MAX];
1160	int vrc = RTPathAbs(pszHostPath, szAbsHostPath, sizeof(szAbsHostPath));
1161	if (RT_FAILURE(vrc))
1162	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTAbsPath failed on '%s': %Rrc", pszHostPath, vrc);
1163
1164	/*
1165	* Done parsing, do some work.
1166	*/
1167	ComPtr<IMachine> ptrMachine;
1168	CHECK_ERROR2I_RET(a->virtualBox, FindMachine(Bstr(pszMachineName).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
1169	AssertReturn(ptrMachine.isNotNull(), RTEXITCODE_FAILURE);
1170
1171	HRESULT hrc;
1172	if (fTransient)
1173	{
1174	/* open an existing session for the VM */
1175	CHECK_ERROR2I_RET(ptrMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
1176
1177	/* get the session machine */
1178	ComPtr<IMachine> ptrSessionMachine;
1179	CHECK_ERROR2I_RET(a->session, COMGETTER(Machine)(ptrSessionMachine.asOutParam()), RTEXITCODE_FAILURE);
1180
1181	/* get the session console */
1182	ComPtr<IConsole> ptrConsole;
1183	CHECK_ERROR2I_RET(a->session, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
1184	if (ptrConsole.isNull())
1185	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running.", pszMachineName);
1186
1187	CHECK_ERROR2(hrc, ptrConsole, CreateSharedFolder(Bstr(pszName).raw(), Bstr(szAbsHostPath).raw(),
1188	fWritable, fAutoMount, Bstr(pszAutoMountPoint).raw()));
1189	a->session->UnlockMachine();
1190	}
1191	else
1192	{
1193	/* open a session for the VM */
1194	CHECK_ERROR2I_RET(ptrMachine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
1195
1196	/* get the mutable session machine */
1197	ComPtr<IMachine> ptrSessionMachine;
1198	CHECK_ERROR2I_RET(a->session, COMGETTER(Machine)(ptrSessionMachine.asOutParam()), RTEXITCODE_FAILURE);
1199
1200	CHECK_ERROR2(hrc, ptrSessionMachine, CreateSharedFolder(Bstr(pszName).raw(), Bstr(szAbsHostPath).raw(),
1201	fWritable, fAutoMount, Bstr(pszAutoMountPoint).raw()));
1202	if (SUCCEEDED(hrc))
1203	{
1204	CHECK_ERROR2(hrc, ptrSessionMachine, SaveSettings());
1205	}
1206
1207	a->session->UnlockMachine();
1208	}
1209
1210	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1211	}
1212
1213	/**
1214	* sharedfolder remove
1215	*/
1216	static RTEXITCODE handleSharedFolderRemove(HandlerArg *a)
1217	{
1218	/*
1219	* Parse arguments (argv[0] == subcommand).
1220	*/
1221	static const RTGETOPTDEF s_aRemoveOptions[] =
1222	{
1223	{ "--name", 'n', RTGETOPT_REQ_STRING },
1224	{ "-name", 'n', RTGETOPT_REQ_STRING }, // deprecated
1225	{ "--transient", 't', RTGETOPT_REQ_NOTHING },
1226	{ "-transient", 't', RTGETOPT_REQ_NOTHING }, // deprecated
1227	};
1228	const char *pszMachineName = NULL;
1229	const char *pszName = NULL;
1230	bool fTransient = false;
1231
1232	RTGETOPTSTATE GetState;
1233	RTGetOptInit(&GetState, a->argc, a->argv, s_aRemoveOptions, RT_ELEMENTS(s_aRemoveOptions), 1 /iFirst/, 0 /fFlags/);
1234	int c;
1235	RTGETOPTUNION ValueUnion;
1236	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1237	{
1238	switch (c)
1239	{
1240	case 'n':
1241	pszName = ValueUnion.psz;
1242	break;
1243	case 't':
1244	fTransient = true;
1245	break;
1246	case VINF_GETOPT_NOT_OPTION:
1247	if (pszMachineName)
1248	return errorArgument("Machine name is given more than once: first '%s', then '%s'",
1249	pszMachineName, ValueUnion.psz);
1250	pszMachineName = ValueUnion.psz;
1251	break;
1252	default:
1253	return errorGetOpt(c, &ValueUnion);
1254	}
1255	}
1256
1257	if (!pszMachineName)
1258	return errorSyntax("No machine was specified");
1259	if (!pszName)
1260	return errorSyntax("No shared folder name (--name) was given");
1261
1262	/*
1263	* Done parsing, do some real work.
1264	*/
1265	ComPtr<IMachine> ptrMachine;
1266	CHECK_ERROR2I_RET(a->virtualBox, FindMachine(Bstr(pszMachineName).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
1267	AssertReturn(ptrMachine.isNotNull(), RTEXITCODE_FAILURE);
1268
1269	HRESULT hrc;
1270	if (fTransient)
1271	{
1272	/* open an existing session for the VM */
1273	CHECK_ERROR2I_RET(ptrMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
1274	/* get the session machine */
1275	ComPtr<IMachine> ptrSessionMachine;
1276	CHECK_ERROR2I_RET(a->session, COMGETTER(Machine)(ptrSessionMachine.asOutParam()), RTEXITCODE_FAILURE);
1277	/* get the session console */
1278	ComPtr<IConsole> ptrConsole;
1279	CHECK_ERROR2I_RET(a->session, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
1280	if (ptrConsole.isNull())
1281	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running.\n", pszMachineName);
1282
1283	CHECK_ERROR2(hrc, ptrConsole, RemoveSharedFolder(Bstr(pszName).raw()));
1284
1285	a->session->UnlockMachine();
1286	}
1287	else
1288	{
1289	/* open a session for the VM */
1290	CHECK_ERROR2I_RET(ptrMachine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
1291
1292	/* get the mutable session machine */
1293	ComPtr<IMachine> ptrSessionMachine;
1294	CHECK_ERROR2I_RET(a->session, COMGETTER(Machine)(ptrSessionMachine.asOutParam()), RTEXITCODE_FAILURE);
1295
1296	CHECK_ERROR2(hrc, ptrSessionMachine, RemoveSharedFolder(Bstr(pszName).raw()));
1297
1298	/* commit and close the session */
1299	if (SUCCEEDED(hrc))
1300	{
1301	CHECK_ERROR2(hrc, ptrSessionMachine, SaveSettings());
1302	}
1303	a->session->UnlockMachine();
1304	}
1305
1306	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1307	}
1308
1309
1310	RTEXITCODE handleSharedFolder(HandlerArg *a)
1311	{
1312	if (a->argc < 1)
1313	return errorSyntax("Not enough parameters");
1314
1315	if (!strcmp(a->argv[0], "add"))
1316	{
1317	setCurrentSubcommand(HELP_SCOPE_SHAREDFOLDER_ADD);
1318	return handleSharedFolderAdd(a);
1319	}
1320
1321	if (!strcmp(a->argv[0], "remove"))
1322	{
1323	setCurrentSubcommand(HELP_SCOPE_SHAREDFOLDER_REMOVE);
1324	return handleSharedFolderRemove(a);
1325	}
1326
1327	return errorUnknownSubcommand(a->argv[0]);
1328	}
1329
1330	RTEXITCODE handleExtPack(HandlerArg *a)
1331	{
1332	if (a->argc < 1)
1333	return errorNoSubcommand();
1334
1335	ComObjPtr<IExtPackManager> ptrExtPackMgr;
1336	CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), RTEXITCODE_FAILURE);
1337
1338	RTGETOPTSTATE GetState;
1339	RTGETOPTUNION ValueUnion;
1340	int ch;
1341	HRESULT hrc = S_OK;
1342
1343	if (!strcmp(a->argv[0], "install"))
1344	{
1345	setCurrentSubcommand(HELP_SCOPE_EXTPACK_INSTALL);
1346	const char *pszName = NULL;
1347	bool fReplace = false;
1348
1349	static const RTGETOPTDEF s_aInstallOptions[] =
1350	{
1351	{ "--replace", 'r', RTGETOPT_REQ_NOTHING },
1352	{ "--accept-license", 'a', RTGETOPT_REQ_STRING },
1353	};
1354
1355	RTCList<RTCString> lstLicenseHashes;
1356	RTGetOptInit(&GetState, a->argc, a->argv, s_aInstallOptions, RT_ELEMENTS(s_aInstallOptions), 1, 0 /fFlags/);
1357	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1358	{
1359	switch (ch)
1360	{
1361	case 'r':
1362	fReplace = true;
1363	break;
1364
1365	case 'a':
1366	lstLicenseHashes.append(ValueUnion.psz);
1367	lstLicenseHashes[lstLicenseHashes.size() - 1].toLower();
1368	break;
1369
1370	case VINF_GETOPT_NOT_OPTION:
1371	if (pszName)
1372	return errorSyntax("Too many extension pack names given to \"extpack uninstall\"");
1373	pszName = ValueUnion.psz;
1374	break;
1375
1376	default:
1377	return errorGetOpt(ch, &ValueUnion);
1378	}
1379	}
1380	if (!pszName)
1381	return errorSyntax("No extension pack name was given to \"extpack install\"");
1382
1383	char szPath[RTPATH_MAX];
1384	int vrc = RTPathAbs(pszName, szPath, sizeof(szPath));
1385	if (RT_FAILURE(vrc))
1386	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", pszName, vrc);
1387
1388	Bstr bstrTarball(szPath);
1389	Bstr bstrName;
1390	ComPtr<IExtPackFile> ptrExtPackFile;
1391	CHECK_ERROR2I_RET(ptrExtPackMgr, OpenExtPackFile(bstrTarball.raw(), ptrExtPackFile.asOutParam()), RTEXITCODE_FAILURE);
1392	CHECK_ERROR2I_RET(ptrExtPackFile, COMGETTER(Name)(bstrName.asOutParam()), RTEXITCODE_FAILURE);
1393	BOOL fShowLicense = true;
1394	CHECK_ERROR2I_RET(ptrExtPackFile, COMGETTER(ShowLicense)(&fShowLicense), RTEXITCODE_FAILURE);
1395	if (fShowLicense)
1396	{
1397	Bstr bstrLicense;
1398	CHECK_ERROR2I_RET(ptrExtPackFile,
1399	QueryLicense(Bstr("").raw() /* PreferredLocale */,
1400	Bstr("").raw() /* PreferredLanguage */,
1401	Bstr("txt").raw() /* Format */,
1402	bstrLicense.asOutParam()), RTEXITCODE_FAILURE);
1403	Utf8Str strLicense(bstrLicense);
1404	uint8_t abHash[RTSHA256_HASH_SIZE];
1405	char szDigest[RTSHA256_DIGEST_LEN + 1];
1406	RTSha256(strLicense.c_str(), strLicense.length(), abHash);
1407	vrc = RTSha256ToString(abHash, szDigest, sizeof(szDigest));
1408	AssertRCStmt(vrc, szDigest[0] = '\0');
1409	if (lstLicenseHashes.contains(szDigest))
1410	RTPrintf("License accepted.\n");
1411	else
1412	{
1413	RTPrintf("%s\n", strLicense.c_str());
1414	RTPrintf("Do you agree to these license terms and conditions (y/n)? " );
1415	ch = RTStrmGetCh(g_pStdIn);
1416	RTPrintf("\n");
1417	if (ch != 'y' && ch != 'Y')
1418	{
1419	RTPrintf("Installation of \"%ls\" aborted.\n", bstrName.raw());
1420	return RTEXITCODE_FAILURE;
1421	}
1422	if (szDigest[0])
1423	RTPrintf("License accepted. For batch installation add\n"
1424	"--accept-license=%s\n"
1425	"to the VBoxManage command line.\n\n", szDigest);
1426	}
1427	}
1428	ComPtr<IProgress> ptrProgress;
1429	CHECK_ERROR2I_RET(ptrExtPackFile, Install(fReplace, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE);
1430	hrc = showProgress(ptrProgress);
1431	CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to install \"%s\"", szPath), RTEXITCODE_FAILURE);
1432
1433	RTPrintf("Successfully installed \"%ls\".\n", bstrName.raw());
1434	}
1435	else if (!strcmp(a->argv[0], "uninstall"))
1436	{
1437	setCurrentSubcommand(HELP_SCOPE_EXTPACK_UNINSTALL);
1438	const char *pszName = NULL;
1439	bool fForced = false;
1440
1441	static const RTGETOPTDEF s_aUninstallOptions[] =
1442	{
1443	{ "--force", 'f', RTGETOPT_REQ_NOTHING },
1444	};
1445
1446	RTGetOptInit(&GetState, a->argc, a->argv, s_aUninstallOptions, RT_ELEMENTS(s_aUninstallOptions), 1, 0);
1447	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1448	{
1449	switch (ch)
1450	{
1451	case 'f':
1452	fForced = true;
1453	break;
1454
1455	case VINF_GETOPT_NOT_OPTION:
1456	if (pszName)
1457	return errorSyntax("Too many extension pack names given to \"extpack uninstall\"");
1458	pszName = ValueUnion.psz;
1459	break;
1460
1461	default:
1462	return errorGetOpt(ch, &ValueUnion);
1463	}
1464	}
1465	if (!pszName)
1466	return errorSyntax("No extension pack name was given to \"extpack uninstall\"");
1467
1468	Bstr bstrName(pszName);
1469	ComPtr<IProgress> ptrProgress;
1470	CHECK_ERROR2I_RET(ptrExtPackMgr, Uninstall(bstrName.raw(), fForced, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE);
1471	hrc = showProgress(ptrProgress);
1472	CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to uninstall \"%s\"", pszName), RTEXITCODE_FAILURE);
1473
1474	RTPrintf("Successfully uninstalled \"%s\".\n", pszName);
1475	}
1476	else if (!strcmp(a->argv[0], "cleanup"))
1477	{
1478	setCurrentSubcommand(HELP_SCOPE_EXTPACK_CLEANUP);
1479	if (a->argc > 1)
1480	return errorTooManyParameters(&a->argv[1]);
1481	CHECK_ERROR2I_RET(ptrExtPackMgr, Cleanup(), RTEXITCODE_FAILURE);
1482	RTPrintf("Successfully performed extension pack cleanup\n");
1483	}
1484	else
1485	return errorUnknownSubcommand(a->argv[0]);
1486
1487	return RTEXITCODE_SUCCESS;
1488	}
1489
1490	RTEXITCODE handleUnattendedDetect(HandlerArg *a)
1491	{
1492	HRESULT hrc;
1493
1494	/*
1495	* Options. We work directly on an IUnattended instace while parsing
1496	* the options. This saves a lot of extra clutter.
1497	*/
1498	bool fMachineReadable = false;
1499	char szIsoPath[RTPATH_MAX];
1500	szIsoPath[0] = '\0';
1501
1502	/*
1503	* Parse options.
1504	*/
1505	static const RTGETOPTDEF s_aOptions[] =
1506	{
1507	{ "--iso", 'i', RTGETOPT_REQ_STRING },
1508	{ "--machine-readable", 'M', RTGETOPT_REQ_NOTHING },
1509	};
1510
1511	RTGETOPTSTATE GetState;
1512	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1513	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1514
1515	int c;
1516	RTGETOPTUNION ValueUnion;
1517	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1518	{
1519	switch (c)
1520	{
1521	case 'i': // --iso
1522	vrc = RTPathAbs(ValueUnion.psz, szIsoPath, sizeof(szIsoPath));
1523	if (RT_FAILURE(vrc))
1524	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1525	break;
1526
1527	case 'M': // --machine-readable.
1528	fMachineReadable = true;
1529	break;
1530
1531	default:
1532	return errorGetOpt(c, &ValueUnion);
1533	}
1534	}
1535
1536	/*
1537	* Check for required stuff.
1538	*/
1539	if (szIsoPath[0] == '\0')
1540	return errorSyntax("No ISO specified");
1541
1542	/*
1543	* Do the job.
1544	*/
1545	ComPtr<IUnattended> ptrUnattended;
1546	CHECK_ERROR2_RET(hrc, a->virtualBox, CreateUnattendedInstaller(ptrUnattended.asOutParam()), RTEXITCODE_FAILURE);
1547	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(IsoPath)(Bstr(szIsoPath).raw()), RTEXITCODE_FAILURE);
1548	CHECK_ERROR2(hrc, ptrUnattended, DetectIsoOS());
1549	RTEXITCODE rcExit = SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1550
1551	/*
1552	* Retrieve the results.
1553	*/
1554	Bstr bstrDetectedOSTypeId;
1555	CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSTypeId)(bstrDetectedOSTypeId.asOutParam()), RTEXITCODE_FAILURE);
1556	Bstr bstrDetectedVersion;
1557	CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSVersion)(bstrDetectedVersion.asOutParam()), RTEXITCODE_FAILURE);
1558	Bstr bstrDetectedFlavor;
1559	CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSFlavor)(bstrDetectedFlavor.asOutParam()), RTEXITCODE_FAILURE);
1560	Bstr bstrDetectedLanguages;
1561	CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSLanguages)(bstrDetectedLanguages.asOutParam()), RTEXITCODE_FAILURE);
1562	Bstr bstrDetectedHints;
1563	CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSHints)(bstrDetectedHints.asOutParam()), RTEXITCODE_FAILURE);
1564	if (fMachineReadable)
1565	RTPrintf("OSTypeId=\"%ls\"\n"
1566	"OSVersion=\"%ls\"\n"
1567	"OSFlavor=\"%ls\"\n"
1568	"OSLanguages=\"%ls\"\n"
1569	"OSHints=\"%ls\"\n",
1570	bstrDetectedOSTypeId.raw(),
1571	bstrDetectedVersion.raw(),
1572	bstrDetectedFlavor.raw(),
1573	bstrDetectedLanguages.raw(),
1574	bstrDetectedHints.raw());
1575	else
1576	{
1577	RTMsgInfo("Detected '%s' to be:\n", szIsoPath);
1578	RTPrintf(" OS TypeId = %ls\n"
1579	" OS Version = %ls\n"
1580	" OS Flavor = %ls\n"
1581	" OS Languages = %ls\n"
1582	" OS Hints = %ls\n",
1583	bstrDetectedOSTypeId.raw(),
1584	bstrDetectedVersion.raw(),
1585	bstrDetectedFlavor.raw(),
1586	bstrDetectedLanguages.raw(),
1587	bstrDetectedHints.raw());
1588	}
1589
1590	return rcExit;
1591	}
1592
1593	RTEXITCODE handleUnattendedInstall(HandlerArg *a)
1594	{
1595	HRESULT hrc;
1596	char szAbsPath[RTPATH_MAX];
1597
1598	/*
1599	* Options. We work directly on an IUnattended instance while parsing
1600	* the options. This saves a lot of extra clutter.
1601	*/
1602	ComPtr<IUnattended> ptrUnattended;
1603	CHECK_ERROR2_RET(hrc, a->virtualBox, CreateUnattendedInstaller(ptrUnattended.asOutParam()), RTEXITCODE_FAILURE);
1604	RTCList<RTCString> arrPackageSelectionAdjustments;
1605	ComPtr<IMachine> ptrMachine;
1606	bool fDryRun = false;
1607	const char *pszSessionType = "none";
1608
1609	/*
1610	* Parse options.
1611	*/
1612	static const RTGETOPTDEF s_aOptions[] =
1613	{
1614	{ "--iso", 'i', RTGETOPT_REQ_STRING },
1615	{ "--user", 'u', RTGETOPT_REQ_STRING },
1616	{ "--password", 'p', RTGETOPT_REQ_STRING },
1617	{ "--password-file", 'X', RTGETOPT_REQ_STRING },
1618	{ "--full-user-name", 'U', RTGETOPT_REQ_STRING },
1619	{ "--key", 'k', RTGETOPT_REQ_STRING },
1620	{ "--install-additions", 'A', RTGETOPT_REQ_NOTHING },
1621	{ "--no-install-additions", 'N', RTGETOPT_REQ_NOTHING },
1622	{ "--additions-iso", 'a', RTGETOPT_REQ_STRING },
1623	{ "--install-txs", 't', RTGETOPT_REQ_NOTHING },
1624	{ "--no-install-txs", 'T', RTGETOPT_REQ_NOTHING },
1625	{ "--validation-kit-iso", 'K', RTGETOPT_REQ_STRING },
1626	{ "--locale", 'l', RTGETOPT_REQ_STRING },
1627	{ "--country", 'Y', RTGETOPT_REQ_STRING },
1628	{ "--time-zone", 'z', RTGETOPT_REQ_STRING },
1629	{ "--proxy", 'y', RTGETOPT_REQ_STRING },
1630	{ "--hostname", 'H', RTGETOPT_REQ_STRING },
1631	{ "--package-selection-adjustment", 's', RTGETOPT_REQ_STRING },
1632	{ "--dry-run", 'D', RTGETOPT_REQ_NOTHING },
1633	// advance options:
1634	{ "--auxiliary-base-path", 'x', RTGETOPT_REQ_STRING },
1635	{ "--image-index", 'm', RTGETOPT_REQ_UINT32 },
1636	{ "--script-template", 'c', RTGETOPT_REQ_STRING },
1637	{ "--post-install-template", 'C', RTGETOPT_REQ_STRING },
1638	{ "--post-install-command", 'P', RTGETOPT_REQ_STRING },
1639	{ "--extra-install-kernel-parameters", 'I', RTGETOPT_REQ_STRING },
1640	{ "--language", 'L', RTGETOPT_REQ_STRING },
1641	// start vm related options:
1642	{ "--start-vm", 'S', RTGETOPT_REQ_STRING },
1643	/** @todo Add a --wait option too for waiting for the VM to shut down or
1644	* something like that...? */
1645	};
1646
1647	RTGETOPTSTATE GetState;
1648	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1649	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1650
1651	int c;
1652	RTGETOPTUNION ValueUnion;
1653	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
1654	{
1655	switch (c)
1656	{
1657	case VINF_GETOPT_NOT_OPTION:
1658	if (ptrMachine.isNotNull())
1659	return errorSyntax("VM name/UUID given more than once!");
1660	CHECK_ERROR2_RET(hrc, a->virtualBox, FindMachine(Bstr(ValueUnion.psz).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
1661	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Machine)(ptrMachine), RTEXITCODE_FAILURE);
1662	break;
1663
1664	case 'i': // --iso
1665	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1666	if (RT_FAILURE(vrc))
1667	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1668	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(IsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1669	break;
1670
1671	case 'u': // --user
1672	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(User)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1673	break;
1674
1675	case 'p': // --password
1676	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Password)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1677	break;
1678
1679	case 'X': // --password-file
1680	{
1681	Utf8Str strPassword;
1682	RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &strPassword);
1683	if (rcExit != RTEXITCODE_SUCCESS)
1684	return rcExit;
1685	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Password)(Bstr(strPassword).raw()), RTEXITCODE_FAILURE);
1686	break;
1687	}
1688
1689	case 'U': // --full-user-name
1690	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(FullUserName)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1691	break;
1692
1693	case 'k': // --key
1694	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ProductKey)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1695	break;
1696
1697	case 'A': // --install-additions
1698	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallGuestAdditions)(TRUE), RTEXITCODE_FAILURE);
1699	break;
1700	case 'N': // --no-install-additions
1701	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallGuestAdditions)(FALSE), RTEXITCODE_FAILURE);
1702	break;
1703	case 'a': // --additions-iso
1704	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1705	if (RT_FAILURE(vrc))
1706	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1707	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AdditionsIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1708	break;
1709
1710	case 't': // --install-txs
1711	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallTestExecService)(TRUE), RTEXITCODE_FAILURE);
1712	break;
1713	case 'T': // --no-install-txs
1714	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallTestExecService)(FALSE), RTEXITCODE_FAILURE);
1715	break;
1716	case 'K': // --valiation-kit-iso
1717	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1718	if (RT_FAILURE(vrc))
1719	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1720	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ValidationKitIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1721	break;
1722
1723	case 'l': // --locale
1724	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Locale)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1725	break;
1726
1727	case 'Y': // --country
1728	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Country)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1729	break;
1730
1731	case 'z': // --time-zone;
1732	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(TimeZone)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1733	break;
1734
1735	case 'y': // --proxy
1736	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Proxy)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1737	break;
1738
1739	case 'H': // --hostname
1740	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Hostname)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1741	break;
1742
1743	case 's': // --package-selection-adjustment
1744	arrPackageSelectionAdjustments.append(ValueUnion.psz);
1745	break;
1746
1747	case 'D':
1748	fDryRun = true;
1749	break;
1750
1751	case 'x': // --auxiliary-base-path
1752	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1753	if (RT_FAILURE(vrc))
1754	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1755	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AuxiliaryBasePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1756	break;
1757
1758	case 'm': // --image-index
1759	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ImageIndex)(ValueUnion.u32), RTEXITCODE_FAILURE);
1760	break;
1761
1762	case 'c': // --script-template
1763	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1764	if (RT_FAILURE(vrc))
1765	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1766	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1767	break;
1768
1769	case 'C': // --post-install-script-template
1770	vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath));
1771	if (RT_FAILURE(vrc))
1772	return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc);
1773	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PostInstallScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE);
1774	break;
1775
1776	case 'P': // --post-install-command.
1777	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PostInstallCommand)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1778	break;
1779
1780	case 'I': // --extra-install-kernel-parameters
1781	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ExtraInstallKernelParameters)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1782	break;
1783
1784	case 'L': // --language
1785	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Language)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE);
1786	break;
1787
1788	case 'S': // --start-vm
1789	pszSessionType = ValueUnion.psz;
1790	break;
1791
1792	default:
1793	return errorGetOpt(c, &ValueUnion);
1794	}
1795	}
1796
1797	/*
1798	* Check for required stuff.
1799	*/
1800	if (ptrMachine.isNull())
1801	return errorSyntax("Missing VM name/UUID");
1802
1803	/*
1804	* Set accumulative attributes.
1805	*/
1806	if (arrPackageSelectionAdjustments.size() == 1)
1807	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PackageSelectionAdjustments)(Bstr(arrPackageSelectionAdjustments[0]).raw()),
1808	RTEXITCODE_FAILURE);
1809	else if (arrPackageSelectionAdjustments.size() > 1)
1810	{
1811	RTCString strAdjustments;
1812	strAdjustments.join(arrPackageSelectionAdjustments, ";");
1813	CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PackageSelectionAdjustments)(Bstr(strAdjustments).raw()), RTEXITCODE_FAILURE);
1814	}
1815
1816	/*
1817	* Get details about the machine so we can display them below.
1818	*/
1819	Bstr bstrMachineName;
1820	CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(Name)(bstrMachineName.asOutParam()), RTEXITCODE_FAILURE);
1821	Bstr bstrUuid;
1822	CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(Id)(bstrUuid.asOutParam()), RTEXITCODE_FAILURE);
1823	BSTR bstrInstalledOS;
1824	CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(OSTypeId)(&bstrInstalledOS), RTEXITCODE_FAILURE);
1825	Utf8Str strInstalledOS(bstrInstalledOS);
1826
1827	/*
1828	* Temporarily lock the machine to check whether it's running or not.
1829	* We take this opportunity to disable the first run wizard.
1830	*/
1831	CHECK_ERROR2_RET(hrc, ptrMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE);
1832	{
1833	ComPtr<IConsole> ptrConsole;
1834	CHECK_ERROR2(hrc, a->session, COMGETTER(Console)(ptrConsole.asOutParam()));
1835
1836	if ( ptrConsole.isNull()
1837	&& SUCCEEDED(hrc)
1838	&& ( RTStrICmp(pszSessionType, "gui") == 0
1839	\|\| RTStrICmp(pszSessionType, "none") == 0))
1840	{
1841	ComPtr<IMachine> ptrSessonMachine;
1842	CHECK_ERROR2(hrc, a->session, COMGETTER(Machine)(ptrSessonMachine.asOutParam()));
1843	if (ptrSessonMachine.isNotNull())
1844	{
1845	CHECK_ERROR2(hrc, ptrSessonMachine, SetExtraData(Bstr("GUI/FirstRun").raw(), Bstr("0").raw()));
1846	}
1847	}
1848
1849	a->session->UnlockMachine();
1850	if (FAILED(hrc))
1851	return RTEXITCODE_FAILURE;
1852	if (ptrConsole.isNotNull())
1853	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%ls' is currently running", bstrMachineName.raw());
1854	}
1855
1856	/*
1857	* Do the work.
1858	*/
1859	RTMsgInfo("%s unattended installation of %s in machine '%ls' (%ls).\n",
1860	RTStrICmp(pszSessionType, "none") == 0 ? "Preparing" : "Starting",
1861	strInstalledOS.c_str(), bstrMachineName.raw(), bstrUuid.raw());
1862
1863	CHECK_ERROR2_RET(hrc, ptrUnattended,Prepare(), RTEXITCODE_FAILURE);
1864	if (!fDryRun)
1865	{
1866	CHECK_ERROR2_RET(hrc, ptrUnattended, ConstructMedia(), RTEXITCODE_FAILURE);
1867	CHECK_ERROR2_RET(hrc, ptrUnattended, ReconfigureVM(), RTEXITCODE_FAILURE);
1868	}
1869
1870	/*
1871	* Retrieve and display the parameters actually used.
1872	*/
1873	RTMsgInfo("Using values:\n");
1874	#define SHOW_ATTR(a_Attr, a_szText, a_Type, a_szFmt) do { \
1875	a_Type Value; \
1876	HRESULT hrc2 = ptrUnattended->COMGETTER(a_Attr)(&Value); \
1877	if (SUCCEEDED(hrc2)) \
1878	RTPrintf(" %32s = " a_szFmt "\n", a_szText, Value); \
1879	else \
1880	RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \
1881	} while (0)
1882	#define SHOW_STR_ATTR(a_Attr, a_szText) do { \
1883	Bstr bstrString; \
1884	HRESULT hrc2 = ptrUnattended->COMGETTER(a_Attr)(bstrString.asOutParam()); \
1885	if (SUCCEEDED(hrc2)) \
1886	RTPrintf(" %32s = %ls\n", a_szText, bstrString.raw()); \
1887	else \
1888	RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \
1889	} while (0)
1890
1891	SHOW_STR_ATTR(IsoPath, "isoPath");
1892	SHOW_STR_ATTR(User, "user");
1893	SHOW_STR_ATTR(Password, "password");
1894	SHOW_STR_ATTR(FullUserName, "fullUserName");
1895	SHOW_STR_ATTR(ProductKey, "productKey");
1896	SHOW_STR_ATTR(AdditionsIsoPath, "additionsIsoPath");
1897	SHOW_ATTR( InstallGuestAdditions, "installGuestAdditions", BOOL, "%RTbool");
1898	SHOW_STR_ATTR(ValidationKitIsoPath, "validationKitIsoPath");
1899	SHOW_ATTR( InstallTestExecService, "installTestExecService", BOOL, "%RTbool");
1900	SHOW_STR_ATTR(Locale, "locale");
1901	SHOW_STR_ATTR(Country, "country");
1902	SHOW_STR_ATTR(TimeZone, "timeZone");
1903	SHOW_STR_ATTR(Proxy, "proxy");
1904	SHOW_STR_ATTR(Hostname, "hostname");
1905	SHOW_STR_ATTR(PackageSelectionAdjustments, "packageSelectionAdjustments");
1906	SHOW_STR_ATTR(AuxiliaryBasePath, "auxiliaryBasePath");
1907	SHOW_ATTR( ImageIndex, "imageIndex", ULONG, "%u");
1908	SHOW_STR_ATTR(ScriptTemplatePath, "scriptTemplatePath");
1909	SHOW_STR_ATTR(PostInstallScriptTemplatePath, "postInstallScriptTemplatePath");
1910	SHOW_STR_ATTR(PostInstallCommand, "postInstallCommand");
1911	SHOW_STR_ATTR(ExtraInstallKernelParameters, "extraInstallKernelParameters");
1912	SHOW_STR_ATTR(Language, "language");
1913	SHOW_STR_ATTR(DetectedOSTypeId, "detectedOSTypeId");
1914	SHOW_STR_ATTR(DetectedOSVersion, "detectedOSVersion");
1915	SHOW_STR_ATTR(DetectedOSFlavor, "detectedOSFlavor");
1916	SHOW_STR_ATTR(DetectedOSLanguages, "detectedOSLanguages");
1917	SHOW_STR_ATTR(DetectedOSHints, "detectedOSHints");
1918
1919	#undef SHOW_STR_ATTR
1920	#undef SHOW_ATTR
1921
1922	/* We can drop the IUnatteded object now. */
1923	ptrUnattended.setNull();
1924
1925	/*
1926	* Start the VM if requested.
1927	*/
1928	if ( fDryRun
1929	\|\| RTStrICmp(pszSessionType, "none") == 0)
1930	{
1931	if (!fDryRun)
1932	RTMsgInfo("VM '%ls' (%ls) is ready to be started (e.g. VBoxManage startvm).\n", bstrMachineName.raw(), bstrUuid.raw());
1933	hrc = S_OK;
1934	}
1935	else
1936	{
1937	com::SafeArray<IN_BSTR> aBstrEnv;
1938	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS)
1939	/* make sure the VM process will start on the same display as VBoxManage */
1940	const char *pszDisplay = RTEnvGet("DISPLAY");
1941	if (pszDisplay)
1942	aBstrEnv.push_back(BstrFmt("DISPLAY=%s", pszDisplay).raw());
1943	const char *pszXAuth = RTEnvGet("XAUTHORITY");
1944	if (pszXAuth)
1945	aBstrEnv.push_back(BstrFmt("XAUTHORITY=%s", pszXAuth).raw());
1946	#endif
1947	ComPtr<IProgress> ptrProgress;
1948	CHECK_ERROR2(hrc, ptrMachine, LaunchVMProcess(a->session, Bstr(pszSessionType).raw(), ComSafeArrayAsInParam(aBstrEnv), ptrProgress.asOutParam()));
1949	if (SUCCEEDED(hrc) && !ptrProgress.isNull())
1950	{
1951	RTMsgInfo("Waiting for VM '%ls' to power on...\n", bstrMachineName.raw());
1952	CHECK_ERROR2(hrc, ptrProgress, WaitForCompletion(-1));
1953	if (SUCCEEDED(hrc))
1954	{
1955	BOOL fCompleted = true;
1956	CHECK_ERROR2(hrc, ptrProgress, COMGETTER(Completed)(&fCompleted));
1957	if (SUCCEEDED(hrc))
1958	{
1959	ASSERT(fCompleted);
1960
1961	LONG iRc;
1962	CHECK_ERROR2(hrc, ptrProgress, COMGETTER(ResultCode)(&iRc));
1963	if (SUCCEEDED(hrc))
1964	{
1965	if (SUCCEEDED(iRc))
1966	RTMsgInfo("VM '%ls' (%ls) has been successfully started.\n", bstrMachineName.raw(), bstrUuid.raw());
1967	else
1968	{
1969	ProgressErrorInfo info(ptrProgress);
1970	com::GluePrintErrorInfo(info);
1971	}
1972	hrc = iRc;
1973	}
1974	}
1975	}
1976	}
1977
1978	/*
1979	* Do we wait for the VM to power down?
1980	*/
1981	}
1982
1983	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1984	}
1985
1986
1987	RTEXITCODE handleUnattended(HandlerArg *a)
1988	{
1989	/*
1990	* Sub-command switch.
1991	*/
1992	if (a->argc < 1)
1993	return errorNoSubcommand();
1994
1995	if (!strcmp(a->argv[0], "detect"))
1996	{
1997	setCurrentSubcommand(HELP_SCOPE_UNATTENDED_DETECT);
1998	return handleUnattendedDetect(a);
1999	}
2000
2001	if (!strcmp(a->argv[0], "install"))
2002	{
2003	setCurrentSubcommand(HELP_SCOPE_UNATTENDED_INSTALL);
2004	return handleUnattendedInstall(a);
2005	}
2006
2007	/* Consider some kind of create-vm-and-install-guest-os command. */
2008	return errorUnknownSubcommand(a->argv[0]);
2009	}
2010
2011	/**
2012	* Common Cloud profile options.
2013	*/
2014	typedef struct
2015	{
2016	const char *pszProviderName;
2017	const char *pszProfileName;
2018	} CLOUDPROFILECOMMONOPT;
2019	typedef CLOUDPROFILECOMMONOPT *PCLOUDPROFILECOMMONOPT;
2020
2021	/**
2022	* Sets the properties of cloud profile
2023	*
2024	* @returns 0 on success, 1 on failure
2025	*/
2026
2027	static RTEXITCODE setCloudProfileProperties(HandlerArg *a, int iFirst, PCLOUDPROFILECOMMONOPT pCommonOpts)
2028	{
2029
2030	HRESULT hrc = S_OK;
2031
2032	Bstr bstrProvider(pCommonOpts->pszProviderName);
2033	Bstr bstrProfile(pCommonOpts->pszProfileName);
2034
2035	/*
2036	* Parse options.
2037	*/
2038	static const RTGETOPTDEF s_aOptions[] =
2039	{
2040	{ "--clouduser", 'u', RTGETOPT_REQ_STRING },
2041	{ "--fingerprint", 'p', RTGETOPT_REQ_STRING },
2042	{ "--keyfile", 'k', RTGETOPT_REQ_STRING },
2043	{ "--passphrase", 'P', RTGETOPT_REQ_STRING },
2044	{ "--tenancy", 't', RTGETOPT_REQ_STRING },
2045	{ "--compartment", 'c', RTGETOPT_REQ_STRING },
2046	{ "--region", 'r', RTGETOPT_REQ_STRING }
2047	};
2048
2049	RTGETOPTSTATE GetState;
2050	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2051	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2052
2053	com::SafeArray<BSTR> names;
2054	com::SafeArray<BSTR> values;
2055
2056	int c;
2057	RTGETOPTUNION ValueUnion;
2058	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2059	{
2060	switch (c)
2061	{
2062	case 'u': // --clouduser
2063	Bstr("user").detachTo(names.appendedRaw());
2064	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2065	break;
2066	case 'p': // --fingerprint
2067	Bstr("fingerprint").detachTo(names.appendedRaw());
2068	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2069	break;
2070	case 'k': // --keyfile
2071	Bstr("key_file").detachTo(names.appendedRaw());
2072	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2073	break;
2074	case 'P': // --passphrase
2075	Bstr("pass_phrase").detachTo(names.appendedRaw());
2076	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2077	break;
2078	case 't': // --tenancy
2079	Bstr("tenancy").detachTo(names.appendedRaw());
2080	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2081	break;
2082	case 'c': // --compartment
2083	Bstr("compartment").detachTo(names.appendedRaw());
2084	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2085	break;
2086	case 'r': // --region
2087	Bstr("region").detachTo(names.appendedRaw());
2088	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2089	break;
2090	default:
2091	return errorGetOpt(USAGE_CLOUDPROFILE, c, &ValueUnion);
2092	}
2093	}
2094
2095	/* check for required options */
2096	if (bstrProvider.isEmpty())
2097	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
2098	if (bstrProfile.isEmpty())
2099	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
2100
2101	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2102
2103	ComPtr<ICloudProviderManager> pCloudProviderManager;
2104	CHECK_ERROR2_RET(hrc, pVirtualBox,
2105	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
2106	RTEXITCODE_FAILURE);
2107
2108	ComPtr<ICloudProvider> pCloudProvider;
2109
2110	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
2111	GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
2112	RTEXITCODE_FAILURE);
2113
2114	ComPtr<ICloudProfile> pCloudProfile;
2115
2116	if (pCloudProvider)
2117	{
2118	CHECK_ERROR2_RET(hrc, pCloudProvider,
2119	GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
2120	RTEXITCODE_FAILURE);
2121	CHECK_ERROR2_RET(hrc, pCloudProfile,
2122	SetProperties(ComSafeArrayAsInParam(names), ComSafeArrayAsInParam(values)),
2123	RTEXITCODE_FAILURE);
2124	}
2125
2126	CHECK_ERROR2(hrc, pCloudProvider, SaveProfiles());
2127
2128	RTPrintf("Provider %ls: profile '%ls' was updated.\n",bstrProvider.raw(), bstrProfile.raw());
2129
2130	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2131	}
2132
2133	/**
2134	* Gets the properties of cloud profile
2135	*
2136	* @returns 0 on success, 1 on failure
2137	*/
2138	static RTEXITCODE showCloudProfileProperties(HandlerArg *a, PCLOUDPROFILECOMMONOPT pCommonOpts)
2139	{
2140	HRESULT hrc = S_OK;
2141
2142	Bstr bstrProvider(pCommonOpts->pszProviderName);
2143	Bstr bstrProfile(pCommonOpts->pszProfileName);
2144
2145	/* check for required options */
2146	if (bstrProvider.isEmpty())
2147	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
2148	if (bstrProfile.isEmpty())
2149	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
2150
2151	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2152	ComPtr<ICloudProviderManager> pCloudProviderManager;
2153	CHECK_ERROR2_RET(hrc, pVirtualBox,
2154	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
2155	RTEXITCODE_FAILURE);
2156	ComPtr<ICloudProvider> pCloudProvider;
2157	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
2158	GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
2159	RTEXITCODE_FAILURE);
2160
2161	ComPtr<ICloudProfile> pCloudProfile;
2162	if (pCloudProvider)
2163	{
2164	CHECK_ERROR2_RET(hrc, pCloudProvider,
2165	GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
2166	RTEXITCODE_FAILURE);
2167
2168	Bstr bstrProviderID;
2169	pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
2170	RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
2171
2172	com::SafeArray<BSTR> names;
2173	com::SafeArray<BSTR> values;
2174	CHECK_ERROR2_RET(hrc, pCloudProfile,
2175	GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values)),
2176	RTEXITCODE_FAILURE);
2177	size_t cNames = names.size();
2178	size_t cValues = values.size();
2179	bool fFirst = true;
2180	for (size_t k = 0; k < cNames; k++)
2181	{
2182	Bstr value;
2183	if (k < cValues)
2184	value = values[k];
2185	RTPrintf("%s%ls=%ls\n",
2186	fFirst ? "Property: " : " ",
2187	names[k], value.raw());
2188	fFirst = false;
2189	}
2190
2191	RTPrintf("\n");
2192	}
2193
2194	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2195	}
2196
2197	static RTEXITCODE addCloudProfile(HandlerArg *a, int iFirst, PCLOUDPROFILECOMMONOPT pCommonOpts)
2198	{
2199	HRESULT hrc = S_OK;
2200
2201	Bstr bstrProvider(pCommonOpts->pszProviderName);
2202	Bstr bstrProfile(pCommonOpts->pszProfileName);
2203
2204
2205	/* check for required options */
2206	if (bstrProvider.isEmpty())
2207	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
2208	if (bstrProfile.isEmpty())
2209	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
2210
2211	/*
2212	* Parse options.
2213	*/
2214	static const RTGETOPTDEF s_aOptions[] =
2215	{
2216	{ "--clouduser", 'u', RTGETOPT_REQ_STRING },
2217	{ "--fingerprint", 'p', RTGETOPT_REQ_STRING },
2218	{ "--keyfile", 'k', RTGETOPT_REQ_STRING },
2219	{ "--passphrase", 'P', RTGETOPT_REQ_STRING },
2220	{ "--tenancy", 't', RTGETOPT_REQ_STRING },
2221	{ "--compartment", 'c', RTGETOPT_REQ_STRING },
2222	{ "--region", 'r', RTGETOPT_REQ_STRING }
2223	};
2224
2225	RTGETOPTSTATE GetState;
2226	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2227	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2228
2229	com::SafeArray<BSTR> names;
2230	com::SafeArray<BSTR> values;
2231
2232	int c;
2233	RTGETOPTUNION ValueUnion;
2234	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2235	{
2236	switch (c)
2237	{
2238	case 'u': // --clouduser
2239	Bstr("user").detachTo(names.appendedRaw());
2240	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2241	break;
2242	case 'p': // --fingerprint
2243	Bstr("fingerprint").detachTo(names.appendedRaw());
2244	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2245	break;
2246	case 'k': // --keyfile
2247	Bstr("key_file").detachTo(names.appendedRaw());
2248	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2249	break;
2250	case 'P': // --passphrase
2251	Bstr("pass_phrase").detachTo(names.appendedRaw());
2252	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2253	break;
2254	case 't': // --tenancy
2255	Bstr("tenancy").detachTo(names.appendedRaw());
2256	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2257	break;
2258	case 'c': // --compartment
2259	Bstr("compartment").detachTo(names.appendedRaw());
2260	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2261	break;
2262	case 'r': // --region
2263	Bstr("region").detachTo(names.appendedRaw());
2264	Bstr(ValueUnion.psz).detachTo(values.appendedRaw());
2265	break;
2266	default:
2267	return errorGetOpt(USAGE_CLOUDPROFILE, c, &ValueUnion);
2268	}
2269	}
2270
2271	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2272
2273	ComPtr<ICloudProviderManager> pCloudProviderManager;
2274	CHECK_ERROR2_RET(hrc, pVirtualBox,
2275	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
2276	RTEXITCODE_FAILURE);
2277
2278	ComPtr<ICloudProvider> pCloudProvider;
2279	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
2280	GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
2281	RTEXITCODE_FAILURE);
2282
2283	CHECK_ERROR2_RET(hrc, pCloudProvider,
2284	CreateProfile(bstrProfile.raw(),
2285	ComSafeArrayAsInParam(names),
2286	ComSafeArrayAsInParam(values)),
2287	RTEXITCODE_FAILURE);
2288
2289	CHECK_ERROR2(hrc, pCloudProvider, SaveProfiles());
2290
2291	RTPrintf("Provider %ls: profile '%ls' was added.\n",bstrProvider.raw(), bstrProfile.raw());
2292
2293	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2294	}
2295
2296	static RTEXITCODE deleteCloudProfile(HandlerArg *a, PCLOUDPROFILECOMMONOPT pCommonOpts)
2297	{
2298	HRESULT hrc = S_OK;
2299
2300	Bstr bstrProvider(pCommonOpts->pszProviderName);
2301	Bstr bstrProfile(pCommonOpts->pszProfileName);
2302
2303	/* check for required options */
2304	if (bstrProvider.isEmpty())
2305	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --provider is required");
2306	if (bstrProfile.isEmpty())
2307	return errorSyntax(USAGE_CLOUDPROFILE, "Parameter --profile is required");
2308
2309	ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
2310	ComPtr<ICloudProviderManager> pCloudProviderManager;
2311	CHECK_ERROR2_RET(hrc, pVirtualBox,
2312	COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()),
2313	RTEXITCODE_FAILURE);
2314	ComPtr<ICloudProvider> pCloudProvider;
2315	CHECK_ERROR2_RET(hrc, pCloudProviderManager,
2316	GetProviderByShortName(bstrProvider.raw(), pCloudProvider.asOutParam()),
2317	RTEXITCODE_FAILURE);
2318
2319	ComPtr<ICloudProfile> pCloudProfile;
2320	if (pCloudProvider)
2321	{
2322	CHECK_ERROR2_RET(hrc, pCloudProvider,
2323	GetProfileByName(bstrProfile.raw(), pCloudProfile.asOutParam()),
2324	RTEXITCODE_FAILURE);
2325
2326	CHECK_ERROR2_RET(hrc, pCloudProfile,
2327	Remove(),
2328	RTEXITCODE_FAILURE);
2329
2330	CHECK_ERROR2_RET(hrc, pCloudProvider,
2331	SaveProfiles(),
2332	RTEXITCODE_FAILURE);
2333
2334	RTPrintf("Provider %ls: profile '%ls' was deleted.\n",bstrProvider.raw(), bstrProfile.raw());
2335	}
2336
2337	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2338	}
2339
2340	RTEXITCODE handleCloudProfile(HandlerArg *a)
2341	{
2342	if (a->argc < 1)
2343	return errorNoSubcommand();
2344
2345	static const RTGETOPTDEF s_aOptions[] =
2346	{
2347	/* common options */
2348	{ "--provider", 'v', RTGETOPT_REQ_STRING },
2349	{ "--profile", 'f', RTGETOPT_REQ_STRING },
2350	/* subcommands */
2351	{ "add", 1000, RTGETOPT_REQ_NOTHING },
2352	{ "show", 1001, RTGETOPT_REQ_NOTHING },
2353	{ "update", 1002, RTGETOPT_REQ_NOTHING },
2354	{ "delete", 1003, RTGETOPT_REQ_NOTHING },
2355	};
2356
2357	RTGETOPTSTATE GetState;
2358	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
2359	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2360
2361	CLOUDPROFILECOMMONOPT CommonOpts = { NULL, NULL };
2362	int c;
2363	RTGETOPTUNION ValueUnion;
2364	while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
2365	{
2366	switch (c)
2367	{
2368	case 'v': // --provider
2369	CommonOpts.pszProviderName = ValueUnion.psz;
2370	break;
2371	case 'f': // --profile
2372	CommonOpts.pszProfileName = ValueUnion.psz;
2373	break;
2374	/* Sub-commands: */
2375	case 1000:
2376	setCurrentSubcommand(HELP_SCOPE_CLOUDPROFILE_ADD);
2377	return addCloudProfile(a, GetState.iNext, &CommonOpts);
2378	case 1001:
2379	setCurrentSubcommand(HELP_SCOPE_CLOUDPROFILE_SHOW);
2380	return showCloudProfileProperties(a, &CommonOpts);
2381	case 1002:
2382	setCurrentSubcommand(HELP_SCOPE_CLOUDPROFILE_UPDATE);
2383	return setCloudProfileProperties(a, GetState.iNext, &CommonOpts);
2384	case 1003:
2385	setCurrentSubcommand(HELP_SCOPE_CLOUDPROFILE_DELETE);
2386	return deleteCloudProfile(a, &CommonOpts);
2387	case VINF_GETOPT_NOT_OPTION:
2388	return errorUnknownSubcommand(ValueUnion.psz);
2389
2390	default:
2391	return errorGetOpt(c, &ValueUnion);
2392	}
2393	}
2394
2395	return errorNoSubcommand();
2396	}

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

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

Download in other formats: