VBoxManageMisc.cpp@ 91396

Last change on this file since 91396 was 91131, checked in by vboxsync, 3 years ago
VBoxManage: For movevm, treat the "no target specified" case so that the API knows to move to the same location.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.1 KB

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

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

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

Download in other formats: