VBoxManageDisk.cpp@ 57511

Last change on this file since 57511 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 65.7 KB

Line
1	/* $Id: VBoxManageDisk.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* VBoxManage - The disk/medium related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef VBOX_ONLY_DOCS
19
20
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#include <VBox/com/com.h>
25	#include <VBox/com/array.h>
26	#include <VBox/com/ErrorInfo.h>
27	#include <VBox/com/errorprint.h>
28	#include <VBox/com/VirtualBox.h>
29
30	#include <iprt/asm.h>
31	#include <iprt/file.h>
32	#include <iprt/path.h>
33	#include <iprt/param.h>
34	#include <iprt/stream.h>
35	#include <iprt/string.h>
36	#include <iprt/ctype.h>
37	#include <iprt/getopt.h>
38	#include <VBox/log.h>
39	#include <VBox/vd.h>
40
41	#include "VBoxManage.h"
42	using namespace com;
43
44
45	// funcs
46	///////////////////////////////////////////////////////////////////////////////
47
48
49	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
50	{
51	RTMsgErrorV(pszFormat, va);
52	RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
53	}
54
55	static int parseMediumVariant(const char psz, MediumVariant_T pMediumVariant)
56	{
57	int rc = VINF_SUCCESS;
58	unsigned uMediumVariant = (unsigned)(*pMediumVariant);
59	while (psz && *psz && RT_SUCCESS(rc))
60	{
61	size_t len;
62	const char *pszComma = strchr(psz, ',');
63	if (pszComma)
64	len = pszComma - psz;
65	else
66	len = strlen(psz);
67	if (len > 0)
68	{
69	// Parsing is intentionally inconsistent: "standard" resets the
70	// variant, whereas the other flags are cumulative.
71	if (!RTStrNICmp(psz, "standard", len))
72	uMediumVariant = MediumVariant_Standard;
73	else if ( !RTStrNICmp(psz, "fixed", len)
74	\|\| !RTStrNICmp(psz, "static", len))
75	uMediumVariant \|= MediumVariant_Fixed;
76	else if (!RTStrNICmp(psz, "Diff", len))
77	uMediumVariant \|= MediumVariant_Diff;
78	else if (!RTStrNICmp(psz, "split2g", len))
79	uMediumVariant \|= MediumVariant_VmdkSplit2G;
80	else if ( !RTStrNICmp(psz, "stream", len)
81	\|\| !RTStrNICmp(psz, "streamoptimized", len))
82	uMediumVariant \|= MediumVariant_VmdkStreamOptimized;
83	else if (!RTStrNICmp(psz, "esx", len))
84	uMediumVariant \|= MediumVariant_VmdkESX;
85	else
86	rc = VERR_PARSE_ERROR;
87	}
88	if (pszComma)
89	psz += len + 1;
90	else
91	psz += len;
92	}
93
94	if (RT_SUCCESS(rc))
95	*pMediumVariant = (MediumVariant_T)uMediumVariant;
96	return rc;
97	}
98
99	int parseMediumType(const char psz, MediumType_T penmMediumType)
100	{
101	int rc = VINF_SUCCESS;
102	MediumType_T enmMediumType = MediumType_Normal;
103	if (!RTStrICmp(psz, "normal"))
104	enmMediumType = MediumType_Normal;
105	else if (!RTStrICmp(psz, "immutable"))
106	enmMediumType = MediumType_Immutable;
107	else if (!RTStrICmp(psz, "writethrough"))
108	enmMediumType = MediumType_Writethrough;
109	else if (!RTStrICmp(psz, "shareable"))
110	enmMediumType = MediumType_Shareable;
111	else if (!RTStrICmp(psz, "readonly"))
112	enmMediumType = MediumType_Readonly;
113	else if (!RTStrICmp(psz, "multiattach"))
114	enmMediumType = MediumType_MultiAttach;
115	else
116	rc = VERR_PARSE_ERROR;
117
118	if (RT_SUCCESS(rc))
119	*penmMediumType = enmMediumType;
120	return rc;
121	}
122
123	/** @todo move this into getopt, as getting bool values is generic */
124	int parseBool(const char psz, bool pb)
125	{
126	int rc = VINF_SUCCESS;
127	if ( !RTStrICmp(psz, "on")
128	\|\| !RTStrICmp(psz, "yes")
129	\|\| !RTStrICmp(psz, "true")
130	\|\| !RTStrICmp(psz, "1")
131	\|\| !RTStrICmp(psz, "enable")
132	\|\| !RTStrICmp(psz, "enabled"))
133	{
134	*pb = true;
135	}
136	else if ( !RTStrICmp(psz, "off")
137	\|\| !RTStrICmp(psz, "no")
138	\|\| !RTStrICmp(psz, "false")
139	\|\| !RTStrICmp(psz, "0")
140	\|\| !RTStrICmp(psz, "disable")
141	\|\| !RTStrICmp(psz, "disabled"))
142	{
143	*pb = false;
144	}
145	else
146	rc = VERR_PARSE_ERROR;
147
148	return rc;
149	}
150
151	HRESULT openMedium(HandlerArg a, const char pszFilenameOrUuid,
152	DeviceType_T enmDevType, AccessMode_T enmAccessMode,
153	ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
154	bool fSilent)
155	{
156	HRESULT rc;
157	Guid id(pszFilenameOrUuid);
158	char szFilenameAbs[RTPATH_MAX] = "";
159
160	/* If it is no UUID, convert the filename to an absolute one. */
161	if (!id.isValid())
162	{
163	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
164	if (RT_FAILURE(irc))
165	{
166	if (!fSilent)
167	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid);
168	return E_FAIL;
169	}
170	pszFilenameOrUuid = szFilenameAbs;
171	}
172
173	if (!fSilent)
174	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
175	enmDevType,
176	enmAccessMode,
177	fForceNewUuidOnOpen,
178	pMedium.asOutParam()));
179	else
180	rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
181	enmDevType,
182	enmAccessMode,
183	fForceNewUuidOnOpen,
184	pMedium.asOutParam());
185
186	return rc;
187	}
188
189	static HRESULT createMedium(HandlerArg a, const char pszFormat,
190	const char *pszFilename, DeviceType_T enmDevType,
191	AccessMode_T enmAccessMode, ComPtr<IMedium> &pMedium)
192	{
193	HRESULT rc;
194	char szFilenameAbs[RTPATH_MAX] = "";
195
196	/** @todo laziness shortcut. should really check the MediumFormatCapabilities */
197	if (RTStrICmp(pszFormat, "iSCSI"))
198	{
199	int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs));
200	if (RT_FAILURE(irc))
201	{
202	RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename);
203	return E_FAIL;
204	}
205	pszFilename = szFilenameAbs;
206	}
207
208	CHECK_ERROR(a->virtualBox, CreateMedium(Bstr(pszFormat).raw(),
209	Bstr(pszFilename).raw(),
210	enmAccessMode,
211	enmDevType,
212	pMedium.asOutParam()));
213	return rc;
214	}
215
216	static const RTGETOPTDEF g_aCreateMediumOptions[] =
217	{
218	{ "disk", 'H', RTGETOPT_REQ_NOTHING },
219	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
220	{ "floppy", 'L', RTGETOPT_REQ_NOTHING },
221	{ "--filename", 'f', RTGETOPT_REQ_STRING },
222	{ "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
223	{ "--diffparent", 'd', RTGETOPT_REQ_STRING },
224	{ "--size", 's', RTGETOPT_REQ_UINT64 },
225	{ "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
226	{ "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
227	{ "--format", 'o', RTGETOPT_REQ_STRING },
228	{ "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
229	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
230	{ "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
231	{ "--variant", 'm', RTGETOPT_REQ_STRING },
232	{ "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
233	};
234
235	RTEXITCODE handleCreateMedium(HandlerArg *a)
236	{
237	HRESULT rc;
238	int vrc;
239	const char *filename = NULL;
240	const char *diffparent = NULL;
241	uint64_t size = 0;
242	enum {
243	CMD_NONE,
244	CMD_DISK,
245	CMD_DVD,
246	CMD_FLOPPY
247	} cmd = CMD_NONE;
248	const char *format = NULL;
249	bool fBase = true;
250	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
251
252	int c;
253	RTGETOPTUNION ValueUnion;
254	RTGETOPTSTATE GetState;
255	// start at 0 because main() has hacked both the argc and argv given to us
256	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateMediumOptions, RT_ELEMENTS(g_aCreateMediumOptions),
257	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
258	while ((c = RTGetOpt(&GetState, &ValueUnion)))
259	{
260	switch (c)
261	{
262	case 'H': // disk
263	if (cmd != CMD_NONE)
264	return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
265	cmd = CMD_DISK;
266	break;
267
268	case 'D': // DVD
269	if (cmd != CMD_NONE)
270	return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
271	cmd = CMD_DVD;
272	break;
273
274	case 'L': // floppy
275	if (cmd != CMD_NONE)
276	return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
277	cmd = CMD_FLOPPY;
278	break;
279
280	case 'f': // --filename
281	filename = ValueUnion.psz;
282	break;
283
284	case 'd': // --diffparent
285	diffparent = ValueUnion.psz;
286	fBase = false;
287	break;
288
289	case 's': // --size
290	size = ValueUnion.u64 * _1M;
291	break;
292
293	case 'S': // --sizebyte
294	size = ValueUnion.u64;
295	break;
296
297	case 'o': // --format
298	format = ValueUnion.psz;
299	break;
300
301	case 'F': // --static ("fixed"/"flat")
302	{
303	unsigned uMediumVariant = (unsigned)enmMediumVariant;
304	uMediumVariant \|= MediumVariant_Fixed;
305	enmMediumVariant = (MediumVariant_T)uMediumVariant;
306	break;
307	}
308
309	case 'm': // --variant
310	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
311	if (RT_FAILURE(vrc))
312	return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
313	break;
314
315	case VINF_GETOPT_NOT_OPTION:
316	return errorSyntax(USAGE_CREATEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
317
318	default:
319	if (c > 0)
320	{
321	if (RT_C_IS_PRINT(c))
322	return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option -%c", c);
323	else
324	return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option case %i", c);
325	}
326	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
327	return errorSyntax(USAGE_CREATEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
328	else if (ValueUnion.pDef)
329	return errorSyntax(USAGE_CREATEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
330	else
331	return errorSyntax(USAGE_CREATEMEDIUM, "error: %Rrs", c);
332	}
333	}
334
335	/* check the outcome */
336	if (cmd == CMD_NONE)
337	cmd = CMD_DISK;
338	ComPtr<IMedium> pParentMedium;
339	if (fBase)
340	{
341	if ( !filename
342	\|\| !*filename
343	\|\| size == 0)
344	return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename and --size are required");
345	if (!format \|\| !*format)
346	{
347	if (cmd == CMD_DISK)
348	format = "VDI";
349	else if (cmd == CMD_DVD \|\| cmd == CMD_FLOPPY)
350	{
351	format = "RAW";
352	unsigned uMediumVariant = (unsigned)enmMediumVariant;
353	uMediumVariant \|= MediumVariant_Fixed;
354	enmMediumVariant = (MediumVariant_T)uMediumVariant;
355	}
356	}
357	}
358	else
359	{
360	if ( !filename
361	\|\| !*filename)
362	return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename is required");
363	size = 0;
364	if (cmd != CMD_DISK)
365	return errorSyntax(USAGE_CREATEMEDIUM, "Creating a differencing medium is only supported for hard disks");
366	enmMediumVariant = MediumVariant_Diff;
367	if (!format \|\| !*format)
368	{
369	const char *pszExt = RTPathSuffix(filename);
370	/* Skip over . if there is an extension. */
371	if (pszExt)
372	pszExt++;
373	if (!pszExt \|\| !*pszExt)
374	format = "VDI";
375	else
376	format = pszExt;
377	}
378	rc = openMedium(a, diffparent, DeviceType_HardDisk,
379	AccessMode_ReadWrite, pParentMedium,
380	false /* fForceNewUuidOnOpen /, false / fSilent */);
381	if (FAILED(rc))
382	return RTEXITCODE_FAILURE;
383	if (pParentMedium.isNull())
384	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid parent hard disk reference, avoiding crash");
385	MediumState_T state;
386	CHECK_ERROR(pParentMedium, COMGETTER(State)(&state));
387	if (FAILED(rc))
388	return RTEXITCODE_FAILURE;
389	if (state == MediumState_Inaccessible)
390	{
391	CHECK_ERROR(pParentMedium, RefreshState(&state));
392	if (FAILED(rc))
393	return RTEXITCODE_FAILURE;
394	}
395	}
396	/* check for filename extension */
397	/** @todo use IMediumFormat to cover all extensions generically */
398	Utf8Str strName(filename);
399	if (!RTPathHasSuffix(strName.c_str()))
400	{
401	Utf8Str strFormat(format);
402	if (cmd == CMD_DISK)
403	{
404	if (strFormat.compare("vmdk", RTCString::CaseInsensitive) == 0)
405	strName.append(".vmdk");
406	else if (strFormat.compare("vhd", RTCString::CaseInsensitive) == 0)
407	strName.append(".vhd");
408	else
409	strName.append(".vdi");
410	} else if (cmd == CMD_DVD)
411	strName.append(".iso");
412	else if (cmd == CMD_FLOPPY)
413	strName.append(".img");
414	filename = strName.c_str();
415	}
416
417	ComPtr<IMedium> pMedium;
418	if (cmd == CMD_DISK)
419	rc = createMedium(a, format, filename, DeviceType_HardDisk,
420	AccessMode_ReadWrite, pMedium);
421	else if (cmd == CMD_DVD)
422	rc = createMedium(a, format, filename, DeviceType_DVD,
423	AccessMode_ReadOnly, pMedium);
424	else if (cmd == CMD_FLOPPY)
425	rc = createMedium(a, format, filename, DeviceType_Floppy,
426	AccessMode_ReadWrite, pMedium);
427	else
428	rc = E_INVALIDARG; /* cannot happen but make gcc happy */
429
430	if (SUCCEEDED(rc) && pMedium)
431	{
432	ComPtr<IProgress> pProgress;
433	com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
434
435	for (ULONG i = 0; i < l_variants.size(); ++i)
436	{
437	ULONG temp = enmMediumVariant;
438	temp &= 1<<i;
439	l_variants [i] = (MediumVariant_T)temp;
440	}
441
442	if (fBase)
443	CHECK_ERROR(pMedium, CreateBaseStorage(size, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
444	else
445	CHECK_ERROR(pParentMedium, CreateDiffStorage(pMedium, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
446	if (SUCCEEDED(rc) && pProgress)
447	{
448	rc = showProgress(pProgress);
449	CHECK_PROGRESS_ERROR(pProgress, ("Failed to create medium"));
450	}
451	}
452
453	if (SUCCEEDED(rc) && pMedium)
454	{
455	Bstr uuid;
456	CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
457	RTPrintf("Medium created. UUID: %s\n", Utf8Str(uuid).c_str());
458
459	//CHECK_ERROR(pMedium, Close());
460	}
461	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
462	}
463
464	static const RTGETOPTDEF g_aModifyMediumOptions[] =
465	{
466	{ "disk", 'H', RTGETOPT_REQ_NOTHING },
467	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
468	{ "floppy", 'L', RTGETOPT_REQ_NOTHING },
469	{ "--type", 't', RTGETOPT_REQ_STRING },
470	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
471	{ "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
472	{ "--autoreset", 'z', RTGETOPT_REQ_STRING },
473	{ "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
474	{ "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
475	{ "--property", 'p', RTGETOPT_REQ_STRING },
476	{ "--compact", 'c', RTGETOPT_REQ_NOTHING },
477	{ "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
478	{ "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
479	{ "--resize", 'r', RTGETOPT_REQ_UINT64 },
480	{ "--resizebyte", 'R', RTGETOPT_REQ_UINT64 }
481	};
482
483	RTEXITCODE handleModifyMedium(HandlerArg *a)
484	{
485	HRESULT rc;
486	int vrc;
487	enum {
488	CMD_NONE,
489	CMD_DISK,
490	CMD_DVD,
491	CMD_FLOPPY
492	} cmd = CMD_NONE;
493	ComPtr<IMedium> pMedium;
494	MediumType_T enmMediumType;
495	bool AutoReset = false;
496	SafeArray<BSTR> mediumPropNames;
497	SafeArray<BSTR> mediumPropValues;
498	bool fModifyMediumType = false;
499	bool fModifyAutoReset = false;
500	bool fModifyProperties = false;
501	bool fModifyCompact = false;
502	bool fModifyResize = false;
503	uint64_t cbResize = 0;
504	const char *pszFilenameOrUuid = NULL;
505
506	int c;
507	RTGETOPTUNION ValueUnion;
508	RTGETOPTSTATE GetState;
509	// start at 0 because main() has hacked both the argc and argv given to us
510	RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyMediumOptions, RT_ELEMENTS(g_aModifyMediumOptions),
511	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
512	while ((c = RTGetOpt(&GetState, &ValueUnion)))
513	{
514	switch (c)
515	{
516	case 'H': // disk
517	if (cmd != CMD_NONE)
518	return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
519	cmd = CMD_DISK;
520	break;
521
522	case 'D': // DVD
523	if (cmd != CMD_NONE)
524	return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
525	cmd = CMD_DVD;
526	break;
527
528	case 'L': // floppy
529	if (cmd != CMD_NONE)
530	return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
531	cmd = CMD_FLOPPY;
532	break;
533
534	case 't': // --type
535	vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
536	if (RT_FAILURE(vrc))
537	return errorArgument("Invalid medium type '%s'", ValueUnion.psz);
538	fModifyMediumType = true;
539	break;
540
541	case 'z': // --autoreset
542	vrc = parseBool(ValueUnion.psz, &AutoReset);
543	if (RT_FAILURE(vrc))
544	return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz);
545	fModifyAutoReset = true;
546	break;
547
548	case 'p': // --property
549	{
550	/* Parse 'name=value' */
551	char *pszProperty = RTStrDup(ValueUnion.psz);
552	if (pszProperty)
553	{
554	char *pDelimiter = strchr(pszProperty, '=');
555	if (pDelimiter)
556	{
557	*pDelimiter = '\0';
558
559	Bstr bstrName(pszProperty);
560	Bstr bstrValue(&pDelimiter[1]);
561	bstrName.detachTo(mediumPropNames.appendedRaw());
562	bstrValue.detachTo(mediumPropValues.appendedRaw());
563	fModifyProperties = true;
564	}
565	else
566	{
567	errorArgument("Invalid --property argument '%s'", ValueUnion.psz);
568	rc = E_FAIL;
569	}
570	RTStrFree(pszProperty);
571	}
572	else
573	{
574	RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for medium property '%s'\n", ValueUnion.psz);
575	rc = E_FAIL;
576	}
577	break;
578	}
579
580	case 'c': // --compact
581	fModifyCompact = true;
582	break;
583
584	case 'r': // --resize
585	cbResize = ValueUnion.u64 * _1M;
586	fModifyResize = true;
587	break;
588
589	case 'R': // --resizebyte
590	cbResize = ValueUnion.u64;
591	fModifyResize = true;
592	break;
593
594	case VINF_GETOPT_NOT_OPTION:
595	if (!pszFilenameOrUuid)
596	pszFilenameOrUuid = ValueUnion.psz;
597	else
598	return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
599	break;
600
601	default:
602	if (c > 0)
603	{
604	if (RT_C_IS_PRINT(c))
605	return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option -%c", c);
606	else
607	return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option case %i", c);
608	}
609	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
610	return errorSyntax(USAGE_MODIFYMEDIUM, "unknown option: %s\n", ValueUnion.psz);
611	else if (ValueUnion.pDef)
612	return errorSyntax(USAGE_MODIFYMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
613	else
614	return errorSyntax(USAGE_MODIFYMEDIUM, "error: %Rrs", c);
615	}
616	}
617
618	if (cmd == CMD_NONE)
619	cmd = CMD_DISK;
620
621	if (!pszFilenameOrUuid)
622	return errorSyntax(USAGE_MODIFYMEDIUM, "Medium name or UUID required");
623
624	if (!fModifyMediumType && !fModifyAutoReset && !fModifyProperties && !fModifyCompact && !fModifyResize)
625	return errorSyntax(USAGE_MODIFYMEDIUM, "No operation specified");
626
627	/* Always open the medium if necessary, there is no other way. */
628	if (cmd == CMD_DISK)
629	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
630	AccessMode_ReadWrite, pMedium,
631	false /* fForceNewUuidOnOpen /, false / fSilent */);
632	else if (cmd == CMD_DVD)
633	rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
634	AccessMode_ReadOnly, pMedium,
635	false /* fForceNewUuidOnOpen /, false / fSilent */);
636	else if (cmd == CMD_FLOPPY)
637	rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
638	AccessMode_ReadWrite, pMedium,
639	false /* fForceNewUuidOnOpen /, false / fSilent */);
640	else
641	rc = E_INVALIDARG; /* cannot happen but make gcc happy */
642	if (FAILED(rc))
643	return RTEXITCODE_FAILURE;
644	if (pMedium.isNull())
645	{
646	RTMsgError("Invalid medium reference, avoiding crash");
647	return RTEXITCODE_FAILURE;
648	}
649
650	if (fModifyMediumType)
651	{
652	MediumType_T enmCurrMediumType;
653	CHECK_ERROR(pMedium, COMGETTER(Type)(&enmCurrMediumType));
654
655	if (enmCurrMediumType != enmMediumType)
656	CHECK_ERROR(pMedium, COMSETTER(Type)(enmMediumType));
657	}
658
659	if (fModifyAutoReset)
660	{
661	CHECK_ERROR(pMedium, COMSETTER(AutoReset)(AutoReset));
662	}
663
664	if (fModifyProperties)
665	{
666	CHECK_ERROR(pMedium, SetProperties(ComSafeArrayAsInParam(mediumPropNames), ComSafeArrayAsInParam(mediumPropValues)));
667	}
668
669	if (fModifyCompact)
670	{
671	ComPtr<IProgress> pProgress;
672	CHECK_ERROR(pMedium, Compact(pProgress.asOutParam()));
673	if (SUCCEEDED(rc))
674	rc = showProgress(pProgress);
675	if (FAILED(rc))
676	{
677	if (rc == E_NOTIMPL)
678	RTMsgError("Compact medium operation is not implemented!");
679	else if (rc == VBOX_E_NOT_SUPPORTED)
680	RTMsgError("Compact medium operation for this format is not implemented yet!");
681	else if (!pProgress.isNull())
682	CHECK_PROGRESS_ERROR(pProgress, ("Failed to compact medium"));
683	else
684	RTMsgError("Failed to compact medium!");
685	}
686	}
687
688	if (fModifyResize)
689	{
690	ComPtr<IProgress> pProgress;
691	CHECK_ERROR(pMedium, Resize(cbResize, pProgress.asOutParam()));
692	if (SUCCEEDED(rc))
693	rc = showProgress(pProgress);
694	if (FAILED(rc))
695	{
696	if (rc == E_NOTIMPL)
697	RTMsgError("Resize medium operation is not implemented!");
698	else if (rc == VBOX_E_NOT_SUPPORTED)
699	RTMsgError("Resize medium operation for this format is not implemented yet!");
700	else if (!pProgress.isNull())
701	CHECK_PROGRESS_ERROR(pProgress, ("Failed to resize medium"));
702	else
703	RTMsgError("Failed to resize medium!");
704	}
705	}
706
707	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
708	}
709
710	static const RTGETOPTDEF g_aCloneMediumOptions[] =
711	{
712	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
713	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
714	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
715	{ "--format", 'o', RTGETOPT_REQ_STRING },
716	{ "-format", 'o', RTGETOPT_REQ_STRING },
717	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
718	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
719	{ "--existing", 'E', RTGETOPT_REQ_NOTHING },
720	{ "--variant", 'm', RTGETOPT_REQ_STRING },
721	{ "-variant", 'm', RTGETOPT_REQ_STRING },
722	};
723
724	RTEXITCODE handleCloneMedium(HandlerArg *a)
725	{
726	HRESULT rc;
727	int vrc;
728	enum {
729	CMD_NONE,
730	CMD_DISK,
731	CMD_DVD,
732	CMD_FLOPPY
733	} cmd = CMD_NONE;
734	const char *pszSrc = NULL;
735	const char *pszDst = NULL;
736	Bstr format;
737	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
738	bool fExisting = false;
739
740	int c;
741	RTGETOPTUNION ValueUnion;
742	RTGETOPTSTATE GetState;
743	// start at 0 because main() has hacked both the argc and argv given to us
744	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneMediumOptions, RT_ELEMENTS(g_aCloneMediumOptions),
745	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
746	while ((c = RTGetOpt(&GetState, &ValueUnion)))
747	{
748	switch (c)
749	{
750	case 'd': // disk
751	if (cmd != CMD_NONE)
752	return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
753	cmd = CMD_DISK;
754	break;
755
756	case 'D': // DVD
757	if (cmd != CMD_NONE)
758	return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
759	cmd = CMD_DVD;
760	break;
761
762	case 'f': // floppy
763	if (cmd != CMD_NONE)
764	return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
765	cmd = CMD_FLOPPY;
766	break;
767
768	case 'o': // --format
769	format = ValueUnion.psz;
770	break;
771
772	case 'F': // --static
773	{
774	unsigned uMediumVariant = (unsigned)enmMediumVariant;
775	uMediumVariant \|= MediumVariant_Fixed;
776	enmMediumVariant = (MediumVariant_T)uMediumVariant;
777	break;
778	}
779
780	case 'E': // --existing
781	fExisting = true;
782	break;
783
784	case 'm': // --variant
785	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
786	if (RT_FAILURE(vrc))
787	return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
788	break;
789
790	case VINF_GETOPT_NOT_OPTION:
791	if (!pszSrc)
792	pszSrc = ValueUnion.psz;
793	else if (!pszDst)
794	pszDst = ValueUnion.psz;
795	else
796	return errorSyntax(USAGE_CLONEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
797	break;
798
799	default:
800	if (c > 0)
801	{
802	if (RT_C_IS_GRAPH(c))
803	return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: -%c", c);
804	else
805	return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: %i", c);
806	}
807	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
808	return errorSyntax(USAGE_CLONEMEDIUM, "unknown option: %s", ValueUnion.psz);
809	else if (ValueUnion.pDef)
810	return errorSyntax(USAGE_CLONEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
811	else
812	return errorSyntax(USAGE_CLONEMEDIUM, "error: %Rrs", c);
813	}
814	}
815
816	if (cmd == CMD_NONE)
817	cmd = CMD_DISK;
818	if (!pszSrc)
819	return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory UUID or input file parameter missing");
820	if (!pszDst)
821	return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory output file parameter missing");
822	if (fExisting && (!format.isEmpty() \|\| enmMediumVariant != MediumType_Normal))
823	return errorSyntax(USAGE_CLONEMEDIUM, "Specified options which cannot be used with --existing");
824
825	ComPtr<IMedium> pSrcMedium;
826	ComPtr<IMedium> pDstMedium;
827
828	if (cmd == CMD_DISK)
829	rc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium,
830	false /* fForceNewUuidOnOpen /, false / fSilent */);
831	else if (cmd == CMD_DVD)
832	rc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium,
833	false /* fForceNewUuidOnOpen /, false / fSilent */);
834	else if (cmd == CMD_FLOPPY)
835	rc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium,
836	false /* fForceNewUuidOnOpen /, false / fSilent */);
837	else
838	rc = E_INVALIDARG; /* cannot happen but make gcc happy */
839	if (FAILED(rc))
840	return RTEXITCODE_FAILURE;
841
842	do
843	{
844	/* open/create destination medium */
845	if (fExisting)
846	{
847	if (cmd == CMD_DISK)
848	rc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium,
849	false /* fForceNewUuidOnOpen /, false / fSilent */);
850	else if (cmd == CMD_DVD)
851	rc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium,
852	false /* fForceNewUuidOnOpen /, false / fSilent */);
853	else if (cmd == CMD_FLOPPY)
854	rc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium,
855	false /* fForceNewUuidOnOpen /, false / fSilent */);
856	if (FAILED(rc))
857	break;
858
859	/* Perform accessibility check now. */
860	MediumState_T state;
861	CHECK_ERROR_BREAK(pDstMedium, RefreshState(&state));
862	CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Format)(format.asOutParam()));
863	}
864	else
865	{
866	/* use the format of the source medium if unspecified */
867	if (format.isEmpty())
868	CHECK_ERROR_BREAK(pSrcMedium, COMGETTER(Format)(format.asOutParam()));
869	Utf8Str strFormat(format);
870	if (cmd == CMD_DISK)
871	rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk,
872	AccessMode_ReadWrite, pDstMedium);
873	else if (cmd == CMD_DVD)
874	rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD,
875	AccessMode_ReadOnly, pDstMedium);
876	else if (cmd == CMD_FLOPPY)
877	rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy,
878	AccessMode_ReadWrite, pDstMedium);
879	if (FAILED(rc))
880	break;
881	}
882
883	ComPtr<IProgress> pProgress;
884	com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
885
886	for (ULONG i = 0; i < l_variants.size(); ++i)
887	{
888	ULONG temp = enmMediumVariant;
889	temp &= 1<<i;
890	l_variants [i] = (MediumVariant_T)temp;
891	}
892
893	CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
894
895	rc = showProgress(pProgress);
896	CHECK_PROGRESS_ERROR_BREAK(pProgress, ("Failed to clone medium"));
897
898	Bstr uuid;
899	CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Id)(uuid.asOutParam()));
900
901	RTPrintf("Clone medium created in format '%ls'. UUID: %s\n",
902	format.raw(), Utf8Str(uuid).c_str());
903	}
904	while (0);
905
906	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
907	}
908
909	static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
910	{
911	{ "--format", 'o', RTGETOPT_REQ_STRING },
912	{ "-format", 'o', RTGETOPT_REQ_STRING },
913	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
914	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
915	{ "--variant", 'm', RTGETOPT_REQ_STRING },
916	{ "-variant", 'm', RTGETOPT_REQ_STRING },
917	{ "--uuid", 'u', RTGETOPT_REQ_STRING },
918	};
919
920	RTEXITCODE handleConvertFromRaw(HandlerArg *a)
921	{
922	int rc = VINF_SUCCESS;
923	bool fReadFromStdIn = false;
924	const char *format = "VDI";
925	const char *srcfilename = NULL;
926	const char *dstfilename = NULL;
927	const char *filesize = NULL;
928	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
929	void *pvBuf = NULL;
930	RTUUID uuid;
931	PCRTUUID pUuid = NULL;
932
933	int c;
934	RTGETOPTUNION ValueUnion;
935	RTGETOPTSTATE GetState;
936	// start at 0 because main() has hacked both the argc and argv given to us
937	RTGetOptInit(&GetState, a->argc, a->argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
938	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
939	while ((c = RTGetOpt(&GetState, &ValueUnion)))
940	{
941	switch (c)
942	{
943	case 'u': // --uuid
944	if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz)))
945	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid UUID '%s'", ValueUnion.psz);
946	pUuid = &uuid;
947	break;
948	case 'o': // --format
949	format = ValueUnion.psz;
950	break;
951
952	case 'm': // --variant
953	{
954	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
955	rc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
956	if (RT_FAILURE(rc))
957	return errorArgument("Invalid medium variant '%s'", ValueUnion.psz);
958	/// @todo cleaner solution than assuming 1:1 mapping?
959	uImageFlags = (unsigned)enmMediumVariant;
960	break;
961	}
962	case VINF_GETOPT_NOT_OPTION:
963	if (!srcfilename)
964	{
965	srcfilename = ValueUnion.psz;
966	fReadFromStdIn = !strcmp(srcfilename, "stdin");
967	}
968	else if (!dstfilename)
969	dstfilename = ValueUnion.psz;
970	else if (fReadFromStdIn && !filesize)
971	filesize = ValueUnion.psz;
972	else
973	return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz);
974	break;
975
976	default:
977	return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion);
978	}
979	}
980
981	if (!srcfilename \|\| !dstfilename \|\| (fReadFromStdIn && !filesize))
982	return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters");
983	RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n",
984	srcfilename, dstfilename);
985
986	PVBOXHDD pDisk = NULL;
987
988	PVDINTERFACE pVDIfs = NULL;
989	VDINTERFACEERROR vdInterfaceError;
990	vdInterfaceError.pfnError = handleVDError;
991	vdInterfaceError.pfnMessage = NULL;
992
993	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
994	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
995	AssertRC(rc);
996
997	/* open raw image file. */
998	RTFILE File;
999	if (fReadFromStdIn)
1000	rc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
1001	else
1002	rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1003	if (RT_FAILURE(rc))
1004	{
1005	RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc);
1006	goto out;
1007	}
1008
1009	uint64_t cbFile;
1010	/* get image size. */
1011	if (fReadFromStdIn)
1012	cbFile = RTStrToUInt64(filesize);
1013	else
1014	rc = RTFileGetSize(File, &cbFile);
1015	if (RT_FAILURE(rc))
1016	{
1017	RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc);
1018	goto out;
1019	}
1020
1021	RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n",
1022	(uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M);
1023	char pszComment[256];
1024	RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename);
1025	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1026	if (RT_FAILURE(rc))
1027	{
1028	RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
1029	goto out;
1030	}
1031
1032	Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
1033	(unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
1034	VDGEOMETRY PCHS, LCHS;
1035	PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
1036	PCHS.cHeads = 16;
1037	PCHS.cSectors = 63;
1038	LCHS.cCylinders = 0;
1039	LCHS.cHeads = 0;
1040	LCHS.cSectors = 0;
1041	rc = VDCreateBase(pDisk, format, dstfilename, cbFile,
1042	uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
1043	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1044	if (RT_FAILURE(rc))
1045	{
1046	RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc);
1047	goto out;
1048	}
1049
1050	size_t cbBuffer;
1051	cbBuffer = _1M;
1052	pvBuf = RTMemAlloc(cbBuffer);
1053	if (!pvBuf)
1054	{
1055	rc = VERR_NO_MEMORY;
1056	RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc);
1057	goto out;
1058	}
1059
1060	uint64_t offFile;
1061	offFile = 0;
1062	while (offFile < cbFile)
1063	{
1064	size_t cbRead;
1065	size_t cbToRead;
1066	cbRead = 0;
1067	cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
1068	cbBuffer : (size_t)(cbFile - offFile);
1069	rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
1070	if (RT_FAILURE(rc) \|\| !cbRead)
1071	break;
1072	rc = VDWrite(pDisk, offFile, pvBuf, cbRead);
1073	if (RT_FAILURE(rc))
1074	{
1075	RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc);
1076	goto out;
1077	}
1078	offFile += cbRead;
1079	}
1080
1081	out:
1082	if (pvBuf)
1083	RTMemFree(pvBuf);
1084	if (pDisk)
1085	VDClose(pDisk, RT_FAILURE(rc));
1086	if (File != NIL_RTFILE)
1087	RTFileClose(File);
1088
1089	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1090	}
1091
1092	HRESULT showMediumInfo(const ComPtr<IVirtualBox> &pVirtualBox,
1093	const ComPtr<IMedium> &pMedium,
1094	const char *pszParentUUID,
1095	bool fOptLong)
1096	{
1097	HRESULT rc = S_OK;
1098	do
1099	{
1100	Bstr uuid;
1101	pMedium->COMGETTER(Id)(uuid.asOutParam());
1102	RTPrintf("UUID: %ls\n", uuid.raw());
1103	if (pszParentUUID)
1104	RTPrintf("Parent UUID: %s\n", pszParentUUID);
1105
1106	/* check for accessibility */
1107	MediumState_T enmState;
1108	CHECK_ERROR_BREAK(pMedium, RefreshState(&enmState));
1109	pMedium->RefreshState(&enmState);
1110	const char *pszState = "unknown";
1111	switch (enmState)
1112	{
1113	case MediumState_NotCreated:
1114	pszState = "not created";
1115	break;
1116	case MediumState_Created:
1117	pszState = "created";
1118	break;
1119	case MediumState_LockedRead:
1120	pszState = "locked read";
1121	break;
1122	case MediumState_LockedWrite:
1123	pszState = "locked write";
1124	break;
1125	case MediumState_Inaccessible:
1126	pszState = "inaccessible";
1127	break;
1128	case MediumState_Creating:
1129	pszState = "creating";
1130	break;
1131	case MediumState_Deleting:
1132	pszState = "deleting";
1133	break;
1134	}
1135	RTPrintf("State: %s\n", pszState);
1136
1137	if (fOptLong && enmState == MediumState_Inaccessible)
1138	{
1139	Bstr err;
1140	CHECK_ERROR_BREAK(pMedium, COMGETTER(LastAccessError)(err.asOutParam()));
1141	RTPrintf("Access Error: %ls\n", err.raw());
1142	}
1143
1144	if (fOptLong)
1145	{
1146	Bstr description;
1147	pMedium->COMGETTER(Description)(description.asOutParam());
1148	if (!description.isEmpty())
1149	RTPrintf("Description: %ls\n", description.raw());
1150	}
1151
1152	MediumType_T type;
1153	pMedium->COMGETTER(Type)(&type);
1154	const char *typeStr = "unknown";
1155	switch (type)
1156	{
1157	case MediumType_Normal:
1158	if (pszParentUUID && Guid(pszParentUUID).isValid())
1159	typeStr = "normal (differencing)";
1160	else
1161	typeStr = "normal (base)";
1162	break;
1163	case MediumType_Immutable:
1164	typeStr = "immutable";
1165	break;
1166	case MediumType_Writethrough:
1167	typeStr = "writethrough";
1168	break;
1169	case MediumType_Shareable:
1170	typeStr = "shareable";
1171	break;
1172	case MediumType_Readonly:
1173	typeStr = "readonly";
1174	break;
1175	case MediumType_MultiAttach:
1176	typeStr = "multiattach";
1177	break;
1178	}
1179	RTPrintf("Type: %s\n", typeStr);
1180
1181	/* print out information specific for differencing media */
1182	if (fOptLong && pszParentUUID && Guid(pszParentUUID).isValid())
1183	{
1184	BOOL autoReset = FALSE;
1185	pMedium->COMGETTER(AutoReset)(&autoReset);
1186	RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off");
1187	}
1188
1189	Bstr loc;
1190	pMedium->COMGETTER(Location)(loc.asOutParam());
1191	RTPrintf("Location: %ls\n", loc.raw());
1192
1193	Bstr format;
1194	pMedium->COMGETTER(Format)(format.asOutParam());
1195	RTPrintf("Storage format: %ls\n", format.raw());
1196
1197	if (fOptLong)
1198	{
1199	com::SafeArray<MediumVariant_T> safeArray_variant;
1200
1201	pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(safeArray_variant));
1202	ULONG variant=0;
1203	for (size_t i = 0; i < safeArray_variant.size(); i++)
1204	variant \|= safeArray_variant[i];
1205
1206	const char *variantStr = "unknown";
1207	switch (variant & ~(MediumVariant_Fixed \| MediumVariant_Diff))
1208	{
1209	case MediumVariant_VmdkSplit2G:
1210	variantStr = "split2G";
1211	break;
1212	case MediumVariant_VmdkStreamOptimized:
1213	variantStr = "streamOptimized";
1214	break;
1215	case MediumVariant_VmdkESX:
1216	variantStr = "ESX";
1217	break;
1218	case MediumVariant_Standard:
1219	variantStr = "default";
1220	break;
1221	}
1222	const char *variantTypeStr = "dynamic";
1223	if (variant & MediumVariant_Fixed)
1224	variantTypeStr = "fixed";
1225	else if (variant & MediumVariant_Diff)
1226	variantTypeStr = "differencing";
1227	RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr);
1228	}
1229
1230	LONG64 logicalSize;
1231	pMedium->COMGETTER(LogicalSize)(&logicalSize);
1232	RTPrintf("Capacity: %lld MBytes\n", logicalSize >> 20);
1233	if (fOptLong)
1234	{
1235	LONG64 actualSize;
1236	pMedium->COMGETTER(Size)(&actualSize);
1237	RTPrintf("Size on disk: %lld MBytes\n", actualSize >> 20);
1238	}
1239
1240	Bstr strCipher;
1241	Bstr strPasswordId;
1242	HRESULT rc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
1243	if (SUCCEEDED(rc2))
1244	{
1245	RTPrintf("Encryption: enabled\n");
1246	if (fOptLong)
1247	{
1248	RTPrintf("Cipher: %ls\n", strCipher.raw());
1249	RTPrintf("Password ID: %ls\n", strPasswordId.raw());
1250	}
1251	}
1252	else
1253	RTPrintf("Encryption: disabled\n");
1254
1255	if (fOptLong)
1256	{
1257	com::SafeArray<BSTR> names;
1258	com::SafeArray<BSTR> values;
1259	pMedium->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1260	size_t cNames = names.size();
1261	size_t cValues = values.size();
1262	bool fFirst = true;
1263	for (size_t i = 0; i < cNames; i++)
1264	{
1265	Bstr value;
1266	if (i < cValues)
1267	value = values[i];
1268	RTPrintf("%s%ls=%ls\n",
1269	fFirst ? "Property: " : " ",
1270	names[i], value.raw());
1271	}
1272	}
1273
1274	if (fOptLong)
1275	{
1276	bool fFirst = true;
1277	com::SafeArray<BSTR> machineIds;
1278	pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1279	for (size_t i = 0; i < machineIds.size(); i++)
1280	{
1281	ComPtr<IMachine> pMachine;
1282	CHECK_ERROR(pVirtualBox, FindMachine(machineIds[i], pMachine.asOutParam()));
1283	if (pMachine)
1284	{
1285	Bstr name;
1286	pMachine->COMGETTER(Name)(name.asOutParam());
1287	pMachine->COMGETTER(Id)(uuid.asOutParam());
1288	RTPrintf("%s%ls (UUID: %ls)",
1289	fFirst ? "In use by VMs: " : " ",
1290	name.raw(), machineIds[i]);
1291	fFirst = false;
1292	com::SafeArray<BSTR> snapshotIds;
1293	pMedium->GetSnapshotIds(machineIds[i],
1294	ComSafeArrayAsOutParam(snapshotIds));
1295	for (size_t j = 0; j < snapshotIds.size(); j++)
1296	{
1297	ComPtr<ISnapshot> pSnapshot;
1298	pMachine->FindSnapshot(snapshotIds[j], pSnapshot.asOutParam());
1299	if (pSnapshot)
1300	{
1301	Bstr snapshotName;
1302	pSnapshot->COMGETTER(Name)(snapshotName.asOutParam());
1303	RTPrintf(" [%ls (UUID: %ls)]", snapshotName.raw(), snapshotIds[j]);
1304	}
1305	}
1306	RTPrintf("\n");
1307	}
1308	}
1309	}
1310
1311	if (fOptLong)
1312	{
1313	com::SafeIfaceArray<IMedium> children;
1314	pMedium->COMGETTER(Children)(ComSafeArrayAsOutParam(children));
1315	bool fFirst = true;
1316	for (size_t i = 0; i < children.size(); i++)
1317	{
1318	ComPtr<IMedium> pChild(children[i]);
1319	if (pChild)
1320	{
1321	Bstr childUUID;
1322	pChild->COMGETTER(Id)(childUUID.asOutParam());
1323	RTPrintf("%s%ls\n",
1324	fFirst ? "Child UUIDs: " : " ",
1325	childUUID.raw());
1326	fFirst = false;
1327	}
1328	}
1329	}
1330	}
1331	while (0);
1332
1333	return rc;
1334	}
1335
1336	static const RTGETOPTDEF g_aShowMediumInfoOptions[] =
1337	{
1338	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1339	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1340	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1341	};
1342
1343	RTEXITCODE handleShowMediumInfo(HandlerArg *a)
1344	{
1345	HRESULT rc;
1346	enum {
1347	CMD_NONE,
1348	CMD_DISK,
1349	CMD_DVD,
1350	CMD_FLOPPY
1351	} cmd = CMD_NONE;
1352	const char *pszFilenameOrUuid = NULL;
1353
1354	int c;
1355	RTGETOPTUNION ValueUnion;
1356	RTGETOPTSTATE GetState;
1357	// start at 0 because main() has hacked both the argc and argv given to us
1358	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowMediumInfoOptions, RT_ELEMENTS(g_aShowMediumInfoOptions),
1359	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1360	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1361	{
1362	switch (c)
1363	{
1364	case 'd': // disk
1365	if (cmd != CMD_NONE)
1366	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1367	cmd = CMD_DISK;
1368	break;
1369
1370	case 'D': // DVD
1371	if (cmd != CMD_NONE)
1372	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1373	cmd = CMD_DVD;
1374	break;
1375
1376	case 'f': // floppy
1377	if (cmd != CMD_NONE)
1378	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz);
1379	cmd = CMD_FLOPPY;
1380	break;
1381
1382	case VINF_GETOPT_NOT_OPTION:
1383	if (!pszFilenameOrUuid)
1384	pszFilenameOrUuid = ValueUnion.psz;
1385	else
1386	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid parameter '%s'", ValueUnion.psz);
1387	break;
1388
1389	default:
1390	if (c > 0)
1391	{
1392	if (RT_C_IS_PRINT(c))
1393	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option -%c", c);
1394	else
1395	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option case %i", c);
1396	}
1397	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1398	return errorSyntax(USAGE_SHOWMEDIUMINFO, "unknown option: %s\n", ValueUnion.psz);
1399	else if (ValueUnion.pDef)
1400	return errorSyntax(USAGE_SHOWMEDIUMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1401	else
1402	return errorSyntax(USAGE_SHOWMEDIUMINFO, "error: %Rrs", c);
1403	}
1404	}
1405
1406	if (cmd == CMD_NONE)
1407	cmd = CMD_DISK;
1408
1409	/* check for required options */
1410	if (!pszFilenameOrUuid)
1411	return errorSyntax(USAGE_SHOWMEDIUMINFO, "Medium name or UUID required");
1412
1413	ComPtr<IMedium> pMedium;
1414	if (cmd == CMD_DISK)
1415	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1416	AccessMode_ReadOnly, pMedium,
1417	false /* fForceNewUuidOnOpen /, false / fSilent */);
1418	else if (cmd == CMD_DVD)
1419	rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1420	AccessMode_ReadOnly, pMedium,
1421	false /* fForceNewUuidOnOpen /, false / fSilent */);
1422	else if (cmd == CMD_FLOPPY)
1423	rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1424	AccessMode_ReadOnly, pMedium,
1425	false /* fForceNewUuidOnOpen /, false / fSilent */);
1426	if (FAILED(rc))
1427	return RTEXITCODE_FAILURE;
1428
1429	Utf8Str strParentUUID("base");
1430	ComPtr<IMedium> pParent;
1431	pMedium->COMGETTER(Parent)(pParent.asOutParam());
1432	if (!pParent.isNull())
1433	{
1434	Bstr bstrParentUUID;
1435	pParent->COMGETTER(Id)(bstrParentUUID.asOutParam());
1436	strParentUUID = bstrParentUUID;
1437	}
1438
1439	rc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true);
1440
1441	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1442	}
1443
1444	static const RTGETOPTDEF g_aCloseMediumOptions[] =
1445	{
1446	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1447	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1448	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1449	{ "--delete", 'r', RTGETOPT_REQ_NOTHING },
1450	};
1451
1452	RTEXITCODE handleCloseMedium(HandlerArg *a)
1453	{
1454	HRESULT rc = S_OK;
1455	enum {
1456	CMD_NONE,
1457	CMD_DISK,
1458	CMD_DVD,
1459	CMD_FLOPPY
1460	} cmd = CMD_NONE;
1461	const char *pszFilenameOrUuid = NULL;
1462	bool fDelete = false;
1463
1464	int c;
1465	RTGETOPTUNION ValueUnion;
1466	RTGETOPTSTATE GetState;
1467	// start at 0 because main() has hacked both the argc and argv given to us
1468	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1469	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1470	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1471	{
1472	switch (c)
1473	{
1474	case 'd': // disk
1475	if (cmd != CMD_NONE)
1476	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1477	cmd = CMD_DISK;
1478	break;
1479
1480	case 'D': // DVD
1481	if (cmd != CMD_NONE)
1482	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1483	cmd = CMD_DVD;
1484	break;
1485
1486	case 'f': // floppy
1487	if (cmd != CMD_NONE)
1488	return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz);
1489	cmd = CMD_FLOPPY;
1490	break;
1491
1492	case 'r': // --delete
1493	fDelete = true;
1494	break;
1495
1496	case VINF_GETOPT_NOT_OPTION:
1497	if (!pszFilenameOrUuid)
1498	pszFilenameOrUuid = ValueUnion.psz;
1499	else
1500	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1501	break;
1502
1503	default:
1504	if (c > 0)
1505	{
1506	if (RT_C_IS_PRINT(c))
1507	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c);
1508	else
1509	return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c);
1510	}
1511	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1512	return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1513	else if (ValueUnion.pDef)
1514	return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1515	else
1516	return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c);
1517	}
1518	}
1519
1520	/* check for required options */
1521	if (cmd == CMD_NONE)
1522	cmd = CMD_DISK;
1523	if (!pszFilenameOrUuid)
1524	return errorSyntax(USAGE_CLOSEMEDIUM, "Medium name or UUID required");
1525
1526	ComPtr<IMedium> pMedium;
1527	if (cmd == CMD_DISK)
1528	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1529	AccessMode_ReadWrite, pMedium,
1530	false /* fForceNewUuidOnOpen /, false / fSilent */);
1531	else if (cmd == CMD_DVD)
1532	rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1533	AccessMode_ReadOnly, pMedium,
1534	false /* fForceNewUuidOnOpen /, false / fSilent */);
1535	else if (cmd == CMD_FLOPPY)
1536	rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1537	AccessMode_ReadWrite, pMedium,
1538	false /* fForceNewUuidOnOpen /, false / fSilent */);
1539
1540	if (SUCCEEDED(rc) && pMedium)
1541	{
1542	if (fDelete)
1543	{
1544	ComPtr<IProgress> pProgress;
1545	CHECK_ERROR(pMedium, DeleteStorage(pProgress.asOutParam()));
1546	if (SUCCEEDED(rc))
1547	{
1548	rc = showProgress(pProgress);
1549	CHECK_PROGRESS_ERROR(pProgress, ("Failed to delete medium"));
1550	}
1551	else
1552	RTMsgError("Failed to delete medium. Error code %Rrc", rc);
1553	}
1554	CHECK_ERROR(pMedium, Close());
1555	}
1556
1557	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1558	}
1559
1560	RTEXITCODE handleMediumProperty(HandlerArg *a)
1561	{
1562	HRESULT rc = S_OK;
1563	const char *pszCmd = NULL;
1564	enum {
1565	CMD_NONE,
1566	CMD_DISK,
1567	CMD_DVD,
1568	CMD_FLOPPY
1569	} cmd = CMD_NONE;
1570	const char *pszAction = NULL;
1571	const char *pszFilenameOrUuid = NULL;
1572	const char *pszProperty = NULL;
1573	ComPtr<IMedium> pMedium;
1574
1575	pszCmd = (a->argc > 0) ? a->argv[0] : "";
1576	if ( !RTStrICmp(pszCmd, "disk")
1577	\|\| !RTStrICmp(pszCmd, "dvd")
1578	\|\| !RTStrICmp(pszCmd, "floppy"))
1579	{
1580	if (!RTStrICmp(pszCmd, "disk"))
1581	cmd = CMD_DISK;
1582	else if (!RTStrICmp(pszCmd, "dvd"))
1583	cmd = CMD_DVD;
1584	else if (!RTStrICmp(pszCmd, "floppy"))
1585	cmd = CMD_FLOPPY;
1586	else
1587	{
1588	AssertMsgFailed(("unexpected parameter %s\n", pszCmd));
1589	cmd = CMD_DISK;
1590	}
1591	a->argv++;
1592	a->argc--;
1593	}
1594	else
1595	{
1596	pszCmd = NULL;
1597	cmd = CMD_DISK;
1598	}
1599
1600	if (a->argc == 0)
1601	return errorSyntax(USAGE_MEDIUMPROPERTY, "Missing action");
1602
1603	pszAction = a->argv[0];
1604	if ( RTStrICmp(pszAction, "set")
1605	&& RTStrICmp(pszAction, "get")
1606	&& RTStrICmp(pszAction, "delete"))
1607	return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid action given: %s", pszAction);
1608
1609	if ( ( !RTStrICmp(pszAction, "set")
1610	&& a->argc != 4)
1611	\|\| ( RTStrICmp(pszAction, "set")
1612	&& a->argc != 3))
1613	return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid number of arguments given for action: %s", pszAction);
1614
1615	pszFilenameOrUuid = a->argv[1];
1616	pszProperty = a->argv[2];
1617
1618	if (cmd == CMD_DISK)
1619	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1620	AccessMode_ReadWrite, pMedium,
1621	false /* fForceNewUuidOnOpen /, false / fSilent */);
1622	else if (cmd == CMD_DVD)
1623	rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1624	AccessMode_ReadOnly, pMedium,
1625	false /* fForceNewUuidOnOpen /, false / fSilent */);
1626	else if (cmd == CMD_FLOPPY)
1627	rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1628	AccessMode_ReadWrite, pMedium,
1629	false /* fForceNewUuidOnOpen /, false / fSilent */);
1630	if (SUCCEEDED(rc) && !pMedium.isNull())
1631	{
1632	if (!RTStrICmp(pszAction, "set"))
1633	{
1634	const char *pszValue = a->argv[3];
1635	CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr(pszValue).raw()));
1636	}
1637	else if (!RTStrICmp(pszAction, "get"))
1638	{
1639	Bstr strVal;
1640	CHECK_ERROR(pMedium, GetProperty(Bstr(pszProperty).raw(), strVal.asOutParam()));
1641	if (SUCCEEDED(rc))
1642	RTPrintf("%s=%ls\n", pszProperty, strVal.raw());
1643	}
1644	else if (!RTStrICmp(pszAction, "delete"))
1645	{
1646	const char *pszValue = a->argv[3];
1647	CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr().raw()));
1648	/** @todo */
1649	}
1650	}
1651
1652	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1653	}
1654
1655	static const RTGETOPTDEF g_aEncryptMediumOptions[] =
1656	{
1657	{ "--newpassword", 'n', RTGETOPT_REQ_STRING },
1658	{ "--oldpassword", 'o', RTGETOPT_REQ_STRING },
1659	{ "--cipher", 'c', RTGETOPT_REQ_STRING },
1660	{ "--newpasswordid", 'i', RTGETOPT_REQ_STRING }
1661	};
1662
1663	RTEXITCODE handleEncryptMedium(HandlerArg *a)
1664	{
1665	HRESULT rc;
1666	ComPtr<IMedium> hardDisk;
1667	const char *pszPasswordNew = NULL;
1668	const char *pszPasswordOld = NULL;
1669	const char *pszCipher = NULL;
1670	const char *pszFilenameOrUuid = NULL;
1671	const char *pszNewPasswordId = NULL;
1672	Utf8Str strPasswordNew;
1673	Utf8Str strPasswordOld;
1674
1675	int c;
1676	RTGETOPTUNION ValueUnion;
1677	RTGETOPTSTATE GetState;
1678	// start at 0 because main() has hacked both the argc and argv given to us
1679	RTGetOptInit(&GetState, a->argc, a->argv, g_aEncryptMediumOptions, RT_ELEMENTS(g_aEncryptMediumOptions),
1680	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1681	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1682	{
1683	switch (c)
1684	{
1685	case 'n': // --newpassword
1686	pszPasswordNew = ValueUnion.psz;
1687	break;
1688
1689	case 'o': // --oldpassword
1690	pszPasswordOld = ValueUnion.psz;
1691	break;
1692
1693	case 'c': // --cipher
1694	pszCipher = ValueUnion.psz;
1695	break;
1696
1697	case 'i': // --newpasswordid
1698	pszNewPasswordId = ValueUnion.psz;
1699	break;
1700
1701	case VINF_GETOPT_NOT_OPTION:
1702	if (!pszFilenameOrUuid)
1703	pszFilenameOrUuid = ValueUnion.psz;
1704	else
1705	return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid parameter '%s'", ValueUnion.psz);
1706	break;
1707
1708	default:
1709	if (c > 0)
1710	{
1711	if (RT_C_IS_PRINT(c))
1712	return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option -%c", c);
1713	else
1714	return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option case %i", c);
1715	}
1716	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1717	return errorSyntax(USAGE_ENCRYPTMEDIUM, "unknown option: %s\n", ValueUnion.psz);
1718	else if (ValueUnion.pDef)
1719	return errorSyntax(USAGE_ENCRYPTMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
1720	else
1721	return errorSyntax(USAGE_ENCRYPTMEDIUM, "error: %Rrs", c);
1722	}
1723	}
1724
1725	if (!pszFilenameOrUuid)
1726	return errorSyntax(USAGE_ENCRYPTMEDIUM, "Disk name or UUID required");
1727
1728	if (!pszPasswordNew && !pszPasswordOld)
1729	return errorSyntax(USAGE_ENCRYPTMEDIUM, "No password specified");
1730
1731	if ( (pszPasswordNew && !pszNewPasswordId)
1732	\|\| (!pszPasswordNew && pszNewPasswordId))
1733	return errorSyntax(USAGE_ENCRYPTMEDIUM, "A new password must always have a valid identifier set at the same time");
1734
1735	if (pszPasswordNew)
1736	{
1737	if (!RTStrCmp(pszPasswordNew, "-"))
1738	{
1739	/* Get password from console. */
1740	RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, "Enter new password:");
1741	if (rcExit == RTEXITCODE_FAILURE)
1742	return rcExit;
1743	}
1744	else
1745	{
1746	RTEXITCODE rcExit = readPasswordFile(pszPasswordNew, &strPasswordNew);
1747	if (rcExit == RTEXITCODE_FAILURE)
1748	{
1749	RTMsgError("Failed to read new password from file");
1750	return rcExit;
1751	}
1752	}
1753	}
1754
1755	if (pszPasswordOld)
1756	{
1757	if (!RTStrCmp(pszPasswordOld, "-"))
1758	{
1759	/* Get password from console. */
1760	RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, "Enter old password:");
1761	if (rcExit == RTEXITCODE_FAILURE)
1762	return rcExit;
1763	}
1764	else
1765	{
1766	RTEXITCODE rcExit = readPasswordFile(pszPasswordOld, &strPasswordOld);
1767	if (rcExit == RTEXITCODE_FAILURE)
1768	{
1769	RTMsgError("Failed to read old password from file");
1770	return rcExit;
1771	}
1772	}
1773	}
1774
1775	/* Always open the medium if necessary, there is no other way. */
1776	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1777	AccessMode_ReadWrite, hardDisk,
1778	false /* fForceNewUuidOnOpen /, false / fSilent */);
1779	if (FAILED(rc))
1780	return RTEXITCODE_FAILURE;
1781	if (hardDisk.isNull())
1782	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
1783
1784	ComPtr<IProgress> progress;
1785	CHECK_ERROR(hardDisk, ChangeEncryption(Bstr(strPasswordOld).raw(), Bstr(pszCipher).raw(),
1786	Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(),
1787	progress.asOutParam()));
1788	if (SUCCEEDED(rc))
1789	rc = showProgress(progress);
1790	if (FAILED(rc))
1791	{
1792	if (rc == E_NOTIMPL)
1793	RTMsgError("Encrypt hard disk operation is not implemented!");
1794	else if (rc == VBOX_E_NOT_SUPPORTED)
1795	RTMsgError("Encrypt hard disk operation for this cipher is not implemented yet!");
1796	else if (!progress.isNull())
1797	CHECK_PROGRESS_ERROR(progress, ("Failed to encrypt hard disk"));
1798	else
1799	RTMsgError("Failed to encrypt hard disk!");
1800	}
1801
1802	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1803	}
1804
1805	RTEXITCODE handleCheckMediumPassword(HandlerArg *a)
1806	{
1807	HRESULT rc;
1808	ComPtr<IMedium> hardDisk;
1809	const char *pszFilenameOrUuid = NULL;
1810	Utf8Str strPassword;
1811
1812	if (a->argc != 2)
1813	return errorSyntax(USAGE_MEDIUMENCCHKPWD, "Invalid number of arguments: %d", a->argc);
1814
1815	pszFilenameOrUuid = a->argv[0];
1816
1817	if (!RTStrCmp(a->argv[1], "-"))
1818	{
1819	/* Get password from console. */
1820	RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:");
1821	if (rcExit == RTEXITCODE_FAILURE)
1822	return rcExit;
1823	}
1824	else
1825	{
1826	RTEXITCODE rcExit = readPasswordFile(a->argv[1], &strPassword);
1827	if (rcExit == RTEXITCODE_FAILURE)
1828	{
1829	RTMsgError("Failed to read password from file");
1830	return rcExit;
1831	}
1832	}
1833
1834	/* Always open the medium if necessary, there is no other way. */
1835	rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1836	AccessMode_ReadWrite, hardDisk,
1837	false /* fForceNewUuidOnOpen /, false / fSilent */);
1838	if (FAILED(rc))
1839	return RTEXITCODE_FAILURE;
1840	if (hardDisk.isNull())
1841	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash");
1842
1843	CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw()));
1844	if (SUCCEEDED(rc))
1845	RTPrintf("The given password is correct\n");
1846	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1847	}
1848
1849	#endif /* !VBOX_ONLY_DOCS */

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

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

Download in other formats: