VBoxManageDisk.cpp@ 99204

Last change on this file since 99204 was 99204, checked in by vboxsync, 20 months ago
VBoxManage: nits
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.7 KB

Line
1	/* $Id: VBoxManageDisk.cpp 99204 2023-03-29 06:34:55Z vboxsync $ */
2	/** @file
3	* VBoxManage - The disk/medium related commands.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/com/com.h>
33	#include <VBox/com/array.h>
34	#include <VBox/com/ErrorInfo.h>
35	#include <VBox/com/errorprint.h>
36	#include <VBox/com/VirtualBox.h>
37
38	#include <iprt/asm.h>
39	#include <iprt/base64.h>
40	#include <iprt/file.h>
41	#include <iprt/path.h>
42	#include <iprt/param.h>
43	#include <iprt/stream.h>
44	#include <iprt/string.h>
45	#include <iprt/ctype.h>
46	#include <iprt/getopt.h>
47	#include <VBox/log.h>
48	#include <VBox/vd.h>
49
50	#include <list>
51
52	#include "VBoxManage.h"
53	using namespace com;
54
55	/** Medium category. */
56	typedef enum MEDIUMCATEGORY
57	{
58	MEDIUMCATEGORY_NONE = 0,
59	MEDIUMCATEGORY_DISK,
60	MEDIUMCATEGORY_DVD,
61	MEDIUMCATEGORY_FLOPPY
62	} MEDIUMCATEGORY;
63
64	DECLARE_TRANSLATION_CONTEXT(Disk);
65
66	// funcs
67	///////////////////////////////////////////////////////////////////////////////
68
69
70	static DECLCALLBACK(void) handleVDError(void pvUser, int vrc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
71	{
72	RT_NOREF(pvUser);
73	RTMsgErrorV(pszFormat, va);
74	RTMsgError(Disk::tr("Error code %Rrc at %s(%u) in function %s"), vrc, RT_SRC_POS_ARGS);
75	}
76
77	static int parseMediumVariant(const char psz, MediumVariant_T pMediumVariant)
78	{
79	int vrc = VINF_SUCCESS;
80	unsigned uMediumVariant = (unsigned)*pMediumVariant;
81	while (psz && *psz && RT_SUCCESS(vrc))
82	{
83	size_t len;
84	const char *pszComma = strchr(psz, ',');
85	if (pszComma)
86	len = pszComma - psz;
87	else
88	len = strlen(psz);
89	if (len > 0)
90	{
91	// Parsing is intentionally inconsistent: "standard" resets the
92	// variant, whereas the other flags are cumulative.
93	if (!RTStrNICmp(psz, "standard", len))
94	uMediumVariant = MediumVariant_Standard;
95	else if ( !RTStrNICmp(psz, "fixed", len)
96	\|\| !RTStrNICmp(psz, "static", len))
97	uMediumVariant \|= MediumVariant_Fixed;
98	else if (!RTStrNICmp(psz, "Diff", len))
99	uMediumVariant \|= MediumVariant_Diff;
100	else if (!RTStrNICmp(psz, "split2g", len))
101	uMediumVariant \|= MediumVariant_VmdkSplit2G;
102	else if ( !RTStrNICmp(psz, "stream", len)
103	\|\| !RTStrNICmp(psz, "streamoptimized", len))
104	uMediumVariant \|= MediumVariant_VmdkStreamOptimized;
105	else if (!RTStrNICmp(psz, "esx", len))
106	uMediumVariant \|= MediumVariant_VmdkESX;
107	else if (!RTStrNICmp(psz, "formatted", len))
108	uMediumVariant \|= MediumVariant_Formatted;
109	else if ( !RTStrNICmp(psz, "raw", len)
110	\|\| !RTStrNICmp(psz, "rawdisk", len))
111	uMediumVariant \|= MediumVariant_VmdkRawDisk;
112	else
113	vrc = VERR_PARSE_ERROR;
114	}
115	if (pszComma)
116	psz += len + 1;
117	else
118	psz += len;
119	}
120
121	if (RT_SUCCESS(vrc))
122	*pMediumVariant = (MediumVariant_T)uMediumVariant;
123	return vrc;
124	}
125
126	int parseMediumType(const char psz, MediumType_T penmMediumType)
127	{
128	int vrc = VINF_SUCCESS;
129	MediumType_T enmMediumType = MediumType_Normal;
130	if (!RTStrICmp(psz, "normal"))
131	enmMediumType = MediumType_Normal;
132	else if (!RTStrICmp(psz, "immutable"))
133	enmMediumType = MediumType_Immutable;
134	else if (!RTStrICmp(psz, "writethrough"))
135	enmMediumType = MediumType_Writethrough;
136	else if (!RTStrICmp(psz, "shareable"))
137	enmMediumType = MediumType_Shareable;
138	else if (!RTStrICmp(psz, "readonly"))
139	enmMediumType = MediumType_Readonly;
140	else if (!RTStrICmp(psz, "multiattach"))
141	enmMediumType = MediumType_MultiAttach;
142	else
143	vrc = VERR_PARSE_ERROR;
144
145	if (RT_SUCCESS(vrc))
146	*penmMediumType = enmMediumType;
147	return vrc;
148	}
149
150	/** @todo move this into getopt, as getting bool values is generic */
151	int parseBool(const char psz, bool pb)
152	{
153	int vrc = VINF_SUCCESS;
154	if ( !RTStrICmp(psz, "on")
155	\|\| !RTStrICmp(psz, "yes")
156	\|\| !RTStrICmp(psz, "true")
157	\|\| !RTStrCmp(psz, "1")
158	\|\| !RTStrICmp(psz, "enable")
159	\|\| !RTStrICmp(psz, "enabled"))
160	*pb = true;
161	else if ( !RTStrICmp(psz, "off")
162	\|\| !RTStrICmp(psz, "no")
163	\|\| !RTStrICmp(psz, "false")
164	\|\| !RTStrCmp(psz, "0")
165	\|\| !RTStrICmp(psz, "disable")
166	\|\| !RTStrICmp(psz, "disabled"))
167	*pb = false;
168	else
169	vrc = VERR_PARSE_ERROR;
170
171	return vrc;
172	}
173
174	HRESULT openMedium(HandlerArg a, const char pszFilenameOrUuid,
175	DeviceType_T enmDevType, AccessMode_T enmAccessMode,
176	ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen,
177	bool fSilent)
178	{
179	HRESULT hrc;
180	Guid id(pszFilenameOrUuid);
181	char szFilenameAbs[RTPATH_MAX] = "";
182
183	/* If it is no UUID, convert the filename to an absolute one. */
184	if (!id.isValid())
185	{
186	int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs));
187	if (RT_FAILURE(irc))
188	{
189	if (!fSilent)
190	RTMsgError(Disk::tr("Cannot convert filename \"%s\" to absolute path"), pszFilenameOrUuid);
191	return E_FAIL;
192	}
193	pszFilenameOrUuid = szFilenameAbs;
194	}
195
196	if (!fSilent)
197	CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(),
198	enmDevType,
199	enmAccessMode,
200	fForceNewUuidOnOpen,
201	pMedium.asOutParam()));
202	else
203	hrc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(),
204	enmDevType,
205	enmAccessMode,
206	fForceNewUuidOnOpen,
207	pMedium.asOutParam());
208
209	return hrc;
210	}
211
212	static HRESULT createMedium(HandlerArg a, const char pszFormat,
213	const char *pszFilename, DeviceType_T enmDevType,
214	AccessMode_T enmAccessMode, ComPtr<IMedium> &pMedium)
215	{
216	HRESULT hrc;
217	char szFilenameAbs[RTPATH_MAX] = "";
218
219	/** @todo laziness shortcut. should really check the MediumFormatCapabilities */
220	if (RTStrICmp(pszFormat, "iSCSI"))
221	{
222	int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs));
223	if (RT_FAILURE(irc))
224	{
225	RTMsgError(Disk::tr("Cannot convert filename \"%s\" to absolute path"), pszFilename);
226	return E_FAIL;
227	}
228	pszFilename = szFilenameAbs;
229	}
230
231	CHECK_ERROR(a->virtualBox, CreateMedium(Bstr(pszFormat).raw(),
232	Bstr(pszFilename).raw(),
233	enmAccessMode,
234	enmDevType,
235	pMedium.asOutParam()));
236	return hrc;
237	}
238
239	static const RTGETOPTDEF g_aCreateMediumOptions[] =
240	{
241	{ "disk", 'H', RTGETOPT_REQ_NOTHING },
242	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
243	{ "floppy", 'L', RTGETOPT_REQ_NOTHING },
244	{ "--filename", 'f', RTGETOPT_REQ_STRING },
245	{ "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated
246	{ "--diffparent", 'd', RTGETOPT_REQ_STRING },
247	{ "--size", 's', RTGETOPT_REQ_UINT64 },
248	{ "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated
249	{ "--sizebyte", 'S', RTGETOPT_REQ_UINT64 },
250	{ "--format", 'o', RTGETOPT_REQ_STRING },
251	{ "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated
252	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
253	{ "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated
254	{ "--variant", 'm', RTGETOPT_REQ_STRING },
255	{ "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated
256	{ "--property", 'p', RTGETOPT_REQ_STRING },
257	{ "--property-file",'P', RTGETOPT_REQ_STRING },
258	};
259
260	class MediumProperty
261	{
262	public:
263	const char *m_pszKey;
264	const char m_pszValue; /< Can be binary too. /
265	size_t m_cbValue;
266	char *m_pszFreeValue;
267	MediumProperty() : m_pszKey(NULL), m_pszValue(NULL), m_cbValue(0), m_pszFreeValue(NULL) { }
268	MediumProperty(MediumProperty const &a_rThat)
269	: m_pszKey(a_rThat.m_pszKey)
270	, m_pszValue(a_rThat.m_pszValue)
271	, m_cbValue(a_rThat.m_cbValue)
272	, m_pszFreeValue(NULL)
273	{
274	Assert(a_rThat.m_pszFreeValue == NULL); /* not expected here! */
275	}
276	~MediumProperty()
277	{
278	RTMemFree(m_pszFreeValue);
279	m_pszFreeValue = NULL;
280	}
281
282	private:
283	MediumProperty &operator=(MediumProperty const &a_rThat)
284	{
285	m_pszKey = a_rThat.m_pszKey;
286	m_pszValue = a_rThat.m_pszValue;
287	m_cbValue = a_rThat.m_cbValue;
288	m_pszFreeValue = a_rThat.m_pszFreeValue;
289	if (a_rThat.m_pszFreeValue != NULL)
290	{
291	m_pszFreeValue = (char *)RTMemDup(m_pszValue, m_cbValue + 1);
292	if (!m_pszFreeValue)
293	{
294	RTMsgError(Disk::tr("Out of memory copying '%s'"), m_pszValue);
295	throw std::bad_alloc();
296	}
297	}
298	return *this;
299	}
300	};
301
302	RTEXITCODE handleCreateMedium(HandlerArg *a)
303	{
304	std::list<MediumProperty> lstProperties;
305
306	HRESULT hrc;
307	int vrc;
308	const char *filename = NULL;
309	const char *diffparent = NULL;
310	uint64_t size = 0;
311	enum
312	{
313	CMD_NONE,
314	CMD_DISK,
315	CMD_DVD,
316	CMD_FLOPPY
317	} cmd = CMD_NONE;
318	const char *format = NULL;
319	bool fBase = true;
320	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
321
322	int c;
323	RTGETOPTUNION ValueUnion;
324	RTGETOPTSTATE GetState;
325	// start at 0 because main() has hacked both the argc and argv given to us
326	RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateMediumOptions, RT_ELEMENTS(g_aCreateMediumOptions),
327	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
328	while ((c = RTGetOpt(&GetState, &ValueUnion)))
329	{
330	switch (c)
331	{
332	case 'H': // disk
333	if (cmd != CMD_NONE)
334	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
335	cmd = CMD_DISK;
336	break;
337
338	case 'D': // DVD
339	if (cmd != CMD_NONE)
340	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
341	cmd = CMD_DVD;
342	break;
343
344	case 'L': // floppy
345	if (cmd != CMD_NONE)
346	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
347	cmd = CMD_FLOPPY;
348	break;
349
350	case 'f': // --filename
351	filename = ValueUnion.psz;
352	break;
353
354	case 'd': // --diffparent
355	diffparent = ValueUnion.psz;
356	fBase = false;
357	break;
358
359	case 's': // --size
360	size = ValueUnion.u64 * _1M;
361	break;
362
363	case 'S': // --sizebyte
364	size = ValueUnion.u64;
365	break;
366
367	case 'o': // --format
368	format = ValueUnion.psz;
369	break;
370
371	case 'p': // --property
372	case 'P': // --property-file
373	{
374	/* allocate property kvp, parse, and append to end of singly linked list */
375	char pszValue = (char )strchr(ValueUnion.psz, '=');
376	if (!pszValue)
377	return RTMsgErrorExitFailure(Disk::tr("Invalid key value pair: No '='."));
378
379	lstProperties.push_back(MediumProperty());
380	MediumProperty &rNewProp = lstProperties.back();
381	pszValue++ = '\0'; / Warning! Modifies argument string. */
382	rNewProp.m_pszKey = ValueUnion.psz;
383	if (c == 'p')
384	{
385	rNewProp.m_pszValue = pszValue;
386	rNewProp.m_cbValue = strlen(pszValue);
387	}
388	else // 'P'
389	{
390	RTFILE hValueFile = NIL_RTFILE;
391	vrc = RTFileOpen(&hValueFile, pszValue, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
392	if (RT_FAILURE(vrc))
393	return RTMsgErrorExitFailure(Disk::tr("Cannot open replacement value file '%s': %Rrc"), pszValue, vrc);
394
395	uint64_t cbValue = 0;
396	vrc = RTFileQuerySize(hValueFile, &cbValue);
397	if (RT_SUCCESS(vrc))
398	{
399	if (cbValue <= _16M)
400	{
401	rNewProp.m_cbValue = (size_t)cbValue;
402	rNewProp.m_pszValue = rNewProp.m_pszFreeValue = (char *)RTMemAlloc(rNewProp.m_cbValue + 1);
403	if (rNewProp.m_pszFreeValue)
404	{
405	vrc = RTFileReadAt(hValueFile, 0, rNewProp.m_pszFreeValue, cbValue, NULL);
406	if (RT_SUCCESS(vrc))
407	rNewProp.m_pszFreeValue[rNewProp.m_cbValue] = '\0';
408	else
409	RTMsgError(Disk::tr("Error reading replacement MBR file '%s': %Rrc"), pszValue, vrc);
410	}
411	else
412	vrc = RTMsgErrorRc(VERR_NO_MEMORY, Disk::tr("Out of memory reading '%s': %Rrc"), pszValue, vrc);
413	}
414	else
415	vrc = RTMsgErrorRc(VERR_OUT_OF_RANGE,
416	Disk::tr("Replacement value file '%s' is to big: %Rhcb, max 16MiB"),
417	pszValue, cbValue);
418	}
419	else
420	RTMsgError(Disk::tr("Cannot get the size of the value file '%s': %Rrc"), pszValue, vrc);
421	RTFileClose(hValueFile);
422	if (RT_FAILURE(vrc))
423	return RTEXITCODE_FAILURE;
424	}
425	break;
426	}
427
428	case 'F': // --static ("fixed"/"flat")
429	{
430	unsigned uMediumVariant = (unsigned)enmMediumVariant;
431	uMediumVariant \|= MediumVariant_Fixed;
432	enmMediumVariant = (MediumVariant_T)uMediumVariant;
433	break;
434	}
435
436	case 'm': // --variant
437	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
438	if (RT_FAILURE(vrc))
439	return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
440	break;
441
442	case VINF_GETOPT_NOT_OPTION:
443	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
444
445	default:
446	if (c > 0)
447	{
448	if (RT_C_IS_PRINT(c))
449	return errorSyntax(Disk::tr("Invalid option -%c"), c);
450	else
451	return errorSyntax(Disk::tr("Invalid option case %i"), c);
452	}
453	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
454	return errorSyntax(Disk::tr("unknown option: %s\n"), ValueUnion.psz);
455	else if (ValueUnion.pDef)
456	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
457	else
458	return errorSyntax(Disk::tr("error: %Rrs"), c);
459	}
460	}
461
462	/* check the outcome */
463	if (cmd == CMD_NONE)
464	cmd = CMD_DISK;
465	ComPtr<IMedium> pParentMedium;
466	if (fBase)
467	{
468	if (!filename \|\| !*filename)
469	return errorSyntax(Disk::tr("Parameter --filename is required"));
470	if ((enmMediumVariant & MediumVariant_VmdkRawDisk) == 0 && size == 0)
471	return errorSyntax(Disk::tr("Parameter --size is required"));
472	if (!format \|\| !*format)
473	{
474	if (cmd == CMD_DISK)
475	format = "VDI";
476	else if (cmd == CMD_DVD \|\| cmd == CMD_FLOPPY)
477	{
478	format = "RAW";
479	unsigned uMediumVariant = (unsigned)enmMediumVariant;
480	uMediumVariant \|= MediumVariant_Fixed;
481	enmMediumVariant = (MediumVariant_T)uMediumVariant;
482	}
483	}
484	if ((enmMediumVariant & MediumVariant_VmdkRawDisk) && strcmp(format, "VMDK"))
485	return errorSyntax(Disk::tr("Variant 'Rawdisk' requires '--format=VMDK'"));
486	}
487	else
488	{
489	if ( !filename
490	\|\| !*filename)
491	return errorSyntax(Disk::tr("Parameter --filename is required"));
492	size = 0;
493	if (cmd != CMD_DISK)
494	return errorSyntax(Disk::tr("Creating a differencing medium is only supported for hard disks"));
495	enmMediumVariant = MediumVariant_Diff;
496	if (!format \|\| !*format)
497	{
498	const char *pszExt = RTPathSuffix(filename);
499	/* Skip over . if there is an extension. */
500	if (pszExt)
501	pszExt++;
502	if (!pszExt \|\| !*pszExt)
503	format = "VDI";
504	else
505	format = pszExt;
506	}
507	hrc = openMedium(a, diffparent, DeviceType_HardDisk,
508	AccessMode_ReadWrite, pParentMedium,
509	false /* fForceNewUuidOnOpen /, false / fSilent */);
510	if (FAILED(hrc))
511	return RTEXITCODE_FAILURE;
512	if (pParentMedium.isNull())
513	return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid parent hard disk reference, avoiding crash"));
514	MediumState_T state;
515	CHECK_ERROR(pParentMedium, COMGETTER(State)(&state));
516	if (FAILED(hrc))
517	return RTEXITCODE_FAILURE;
518	if (state == MediumState_Inaccessible)
519	{
520	CHECK_ERROR(pParentMedium, RefreshState(&state));
521	if (FAILED(hrc))
522	return RTEXITCODE_FAILURE;
523	}
524	}
525	/* check for filename extension */
526	/** @todo use IMediumFormat to cover all extensions generically */
527	Utf8Str strName(filename);
528	if (!RTPathHasSuffix(strName.c_str()))
529	{
530	Utf8Str strFormat(format);
531	if (cmd == CMD_DISK)
532	{
533	if (strFormat.compare("vmdk", RTCString::CaseInsensitive) == 0)
534	strName.append(".vmdk");
535	else if (strFormat.compare("vhd", RTCString::CaseInsensitive) == 0)
536	strName.append(".vhd");
537	else
538	strName.append(".vdi");
539	}
540	else if (cmd == CMD_DVD)
541	strName.append(".iso");
542	else if (cmd == CMD_FLOPPY)
543	strName.append(".img");
544	filename = strName.c_str();
545	}
546
547	ComPtr<IMedium> pMedium;
548	if (cmd == CMD_DISK)
549	hrc = createMedium(a, format, filename, DeviceType_HardDisk,
550	AccessMode_ReadWrite, pMedium);
551	else if (cmd == CMD_DVD)
552	hrc = createMedium(a, format, filename, DeviceType_DVD,
553	AccessMode_ReadOnly, pMedium);
554	else if (cmd == CMD_FLOPPY)
555	hrc = createMedium(a, format, filename, DeviceType_Floppy,
556	AccessMode_ReadWrite, pMedium);
557	else
558	hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
559
560
561	if (SUCCEEDED(hrc) && pMedium)
562	{
563	if (lstProperties.size() > 0)
564	{
565	ComPtr<IMediumFormat> pMediumFormat;
566	CHECK_ERROR2I_RET(pMedium, COMGETTER(MediumFormat)(pMediumFormat.asOutParam()), RTEXITCODE_FAILURE);
567	com::SafeArray<BSTR> propertyNames;
568	com::SafeArray<BSTR> propertyDescriptions;
569	com::SafeArray<DataType_T> propertyTypes;
570	com::SafeArray<ULONG> propertyFlags;
571	com::SafeArray<BSTR> propertyDefaults;
572	CHECK_ERROR2I_RET(pMediumFormat,
573	DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
574	ComSafeArrayAsOutParam(propertyDescriptions),
575	ComSafeArrayAsOutParam(propertyTypes),
576	ComSafeArrayAsOutParam(propertyFlags),
577	ComSafeArrayAsOutParam(propertyDefaults)),
578	RTEXITCODE_FAILURE);
579
580	for (std::list<MediumProperty>::iterator it = lstProperties.begin();
581	it != lstProperties.end();
582	++it)
583	{
584	const char * const pszKey = it->m_pszKey;
585	bool fBinary = true;
586	bool fPropertyFound = false;
587	for (size_t i = 0; i < propertyNames.size(); ++i)
588	if (RTUtf16CmpUtf8(propertyNames[i], pszKey) == 0)
589	{
590	fBinary = propertyTypes[i] == DataType_Int8;
591	fPropertyFound = true;
592	break;
593	}
594	if (!fPropertyFound)
595	return RTMsgErrorExit(RTEXITCODE_FAILURE,
596	Disk::tr("Property '%s' was not found in the list of medium properties for the requested medium format (%s)."),
597	pszKey, format);
598	if (!fBinary)
599	CHECK_ERROR2I_RET(pMedium, SetProperty(Bstr(pszKey).raw(), Bstr(it->m_pszValue).raw()),
600	RTEXITCODE_FAILURE);
601	else
602	{
603	com::Bstr bstrBase64Value;
604	hrc = bstrBase64Value.base64Encode(it->m_pszValue, it->m_cbValue);
605	if (FAILED(hrc))
606	return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Base64 encoding of the property %s failed. (%Rhrc)"),
607	pszKey, hrc);
608	CHECK_ERROR2I_RET(pMedium, SetProperty(Bstr(pszKey).raw(), bstrBase64Value.raw()), RTEXITCODE_FAILURE);
609	}
610	}
611	}
612
613	ComPtr<IProgress> pProgress;
614	com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
615
616	for (ULONG i = 0; i < l_variants.size(); ++i)
617	{
618	ULONG temp = enmMediumVariant;
619	temp &= 1<<i;
620	l_variants [i] = (MediumVariant_T)temp;
621	}
622
623	if (fBase)
624	CHECK_ERROR(pMedium, CreateBaseStorage(size, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
625	else
626	CHECK_ERROR(pParentMedium, CreateDiffStorage(pMedium, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam()));
627	if (SUCCEEDED(hrc) && pProgress)
628	{
629	hrc = showProgress(pProgress);
630	CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to create medium")));
631	}
632	}
633
634	if (SUCCEEDED(hrc) && pMedium)
635	{
636	Bstr uuid;
637	CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
638	RTPrintf(Disk::tr("Medium created. UUID: %s\n"), Utf8Str(uuid).c_str());
639
640	//CHECK_ERROR(pMedium, Close());
641	}
642	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
643	}
644
645	static const RTGETOPTDEF g_aModifyMediumOptions[] =
646	{
647	{ "disk", 'H', RTGETOPT_REQ_NOTHING },
648	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
649	{ "floppy", 'L', RTGETOPT_REQ_NOTHING },
650	{ "--type", 't', RTGETOPT_REQ_STRING },
651	{ "-type", 't', RTGETOPT_REQ_STRING }, // deprecated
652	{ "settype", 't', RTGETOPT_REQ_STRING }, // deprecated
653	{ "--autoreset", 'z', RTGETOPT_REQ_STRING },
654	{ "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
655	{ "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated
656	{ "--property", 'p', RTGETOPT_REQ_STRING },
657	{ "--compact", 'c', RTGETOPT_REQ_NOTHING },
658	{ "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
659	{ "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated
660	{ "--resize", 'r', RTGETOPT_REQ_UINT64 },
661	{ "--resizebyte", 'R', RTGETOPT_REQ_UINT64 },
662	{ "--move", 'm', RTGETOPT_REQ_STRING },
663	{ "--setlocation", 'l', RTGETOPT_REQ_STRING },
664	{ "--description", 'd', RTGETOPT_REQ_STRING }
665	};
666
667	RTEXITCODE handleModifyMedium(HandlerArg *a)
668	{
669	HRESULT hrc;
670	int vrc;
671	enum {
672	CMD_NONE,
673	CMD_DISK,
674	CMD_DVD,
675	CMD_FLOPPY
676	} cmd = CMD_NONE;
677	ComPtr<IMedium> pMedium;
678	MediumType_T enmMediumType = MediumType_Normal; /* Shut up MSC */
679	bool AutoReset = false;
680	SafeArray<BSTR> mediumPropNames;
681	SafeArray<BSTR> mediumPropValues;
682	bool fModifyMediumType = false;
683	bool fModifyAutoReset = false;
684	bool fModifyProperties = false;
685	bool fModifyCompact = false;
686	bool fModifyResize = false;
687	bool fModifyResizeMB = false;
688	bool fMoveMedium = false;
689	bool fModifyDescription = false;
690	bool fSetNewLocation = false;
691	uint64_t cbResize = 0;
692	const char *pszFilenameOrUuid = NULL;
693	char *pszNewLocation = NULL;
694
695	int c;
696	RTGETOPTUNION ValueUnion;
697	RTGETOPTSTATE GetState;
698	// start at 0 because main() has hacked both the argc and argv given to us
699	RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyMediumOptions, RT_ELEMENTS(g_aModifyMediumOptions),
700	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
701	while ((c = RTGetOpt(&GetState, &ValueUnion)))
702	{
703	switch (c)
704	{
705	case 'H': // disk
706	if (cmd != CMD_NONE)
707	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
708	cmd = CMD_DISK;
709	break;
710
711	case 'D': // DVD
712	if (cmd != CMD_NONE)
713	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
714	cmd = CMD_DVD;
715	break;
716
717	case 'L': // floppy
718	if (cmd != CMD_NONE)
719	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
720	cmd = CMD_FLOPPY;
721	break;
722
723	case 't': // --type
724	vrc = parseMediumType(ValueUnion.psz, &enmMediumType);
725	if (RT_FAILURE(vrc))
726	return errorArgument(Disk::tr("Invalid medium type '%s'"), ValueUnion.psz);
727	fModifyMediumType = true;
728	break;
729
730	case 'z': // --autoreset
731	vrc = parseBool(ValueUnion.psz, &AutoReset);
732	if (RT_FAILURE(vrc))
733	return errorArgument(Disk::tr("Invalid autoreset parameter '%s'"), ValueUnion.psz);
734	fModifyAutoReset = true;
735	break;
736
737	case 'p': // --property
738	{
739	/* Parse 'name=value' */
740	char *pszProperty = RTStrDup(ValueUnion.psz);
741	if (pszProperty)
742	{
743	char *pDelimiter = strchr(pszProperty, '=');
744	if (pDelimiter)
745	{
746	*pDelimiter = '\0';
747
748	Bstr bstrName(pszProperty);
749	Bstr bstrValue(&pDelimiter[1]);
750	bstrName.detachTo(mediumPropNames.appendedRaw());
751	bstrValue.detachTo(mediumPropValues.appendedRaw());
752	fModifyProperties = true;
753	}
754	else
755	{
756	errorArgument(Disk::tr("Invalid --property argument '%s'"), ValueUnion.psz);
757	hrc = E_FAIL;
758	}
759	RTStrFree(pszProperty);
760	}
761	else
762	{
763	RTStrmPrintf(g_pStdErr, Disk::tr("Error: Failed to allocate memory for medium property '%s'\n"),
764	ValueUnion.psz);
765	hrc = E_FAIL;
766	}
767	break;
768	}
769
770	case 'c': // --compact
771	fModifyCompact = true;
772	break;
773
774	case 'r': // --resize
775	cbResize = ValueUnion.u64 * _1M;
776	fModifyResize = true;
777	fModifyResizeMB = true; // do sanity check!
778	break;
779
780	case 'R': // --resizebyte
781	cbResize = ValueUnion.u64;
782	fModifyResize = true;
783	break;
784
785	case 'm': // --move
786	/* Get a new location */
787	pszNewLocation = RTPathAbsDup(ValueUnion.psz);
788	fMoveMedium = true;
789	break;
790
791	case 'l': // --setlocation
792	/* Get a new location */
793	pszNewLocation = RTPathAbsDup(ValueUnion.psz);
794	fSetNewLocation = true;
795	break;
796
797	case 'd': // --description
798	/* Get a new description */
799	pszNewLocation = RTStrDup(ValueUnion.psz);
800	fModifyDescription = true;
801	break;
802
803	case VINF_GETOPT_NOT_OPTION:
804	if (!pszFilenameOrUuid)
805	pszFilenameOrUuid = ValueUnion.psz;
806	else
807	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
808	break;
809
810	default:
811	if (c > 0)
812	{
813	if (RT_C_IS_PRINT(c))
814	return errorSyntax(Disk::tr("Invalid option -%c"), c);
815	else
816	return errorSyntax(Disk::tr("Invalid option case %i"), c);
817	}
818	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
819	return errorSyntax(Disk::tr("unknown option: %s\n"), ValueUnion.psz);
820	else if (ValueUnion.pDef)
821	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
822	else
823	return errorSyntax(Disk::tr("error: %Rrs"), c);
824	}
825	}
826
827	if (cmd == CMD_NONE)
828	cmd = CMD_DISK;
829
830	if (!pszFilenameOrUuid)
831	return errorSyntax(Disk::tr("Medium name or UUID required"));
832
833	if (!fModifyMediumType
834	&& !fModifyAutoReset
835	&& !fModifyProperties
836	&& !fModifyCompact
837	&& !fModifyResize
838	&& !fMoveMedium
839	&& !fSetNewLocation
840	&& !fModifyDescription
841	)
842	return errorSyntax(Disk::tr("No operation specified"));
843
844	/* Always open the medium if necessary, there is no other way. */
845	if (cmd == CMD_DISK)
846	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
847	AccessMode_ReadWrite, pMedium,
848	false /* fForceNewUuidOnOpen /, false / fSilent */);
849	else if (cmd == CMD_DVD)
850	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
851	AccessMode_ReadOnly, pMedium,
852	false /* fForceNewUuidOnOpen /, false / fSilent */);
853	else if (cmd == CMD_FLOPPY)
854	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
855	AccessMode_ReadWrite, pMedium,
856	false /* fForceNewUuidOnOpen /, false / fSilent */);
857	else
858	hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
859	if (FAILED(hrc))
860	return RTEXITCODE_FAILURE;
861	if (pMedium.isNull())
862	{
863	RTMsgError(Disk::tr("Invalid medium reference, avoiding crash"));
864	return RTEXITCODE_FAILURE;
865	}
866
867	if ( fModifyResize
868	&& fModifyResizeMB)
869	{
870	// Sanity check
871	//
872	// In general users should know what they do but in this case users have no
873	// alternative to VBoxManage. If happens that one wants to resize the disk
874	// and uses --resize and does not consider that this parameter expects the
875	// new medium size in MB not Byte. If the operation is started and then
876	// aborted by the user, the result is most likely a medium which doesn't
877	// work anymore.
878	MediumState_T state;
879	pMedium->RefreshState(&state);
880	LONG64 logicalSize;
881	pMedium->COMGETTER(LogicalSize)(&logicalSize);
882	if (cbResize > (uint64_t)logicalSize * 1000)
883	{
884	RTMsgError(Disk::tr("Error: Attempt to resize the medium from %RU64.%RU64 MB to %RU64.%RU64 MB. Use --resizebyte if this is intended!\n"),
885	logicalSize / _1M, (logicalSize % _1M) / (_1M / 10), cbResize / _1M, (cbResize % _1M) / (_1M / 10));
886	return RTEXITCODE_FAILURE;
887	}
888	}
889
890	if (fModifyMediumType)
891	{
892	MediumType_T enmCurrMediumType;
893	CHECK_ERROR(pMedium, COMGETTER(Type)(&enmCurrMediumType));
894
895	if (enmCurrMediumType != enmMediumType)
896	CHECK_ERROR(pMedium, COMSETTER(Type)(enmMediumType));
897	}
898
899	if (fModifyAutoReset)
900	{
901	CHECK_ERROR(pMedium, COMSETTER(AutoReset)(AutoReset));
902	}
903
904	if (fModifyProperties)
905	{
906	CHECK_ERROR(pMedium, SetProperties(ComSafeArrayAsInParam(mediumPropNames), ComSafeArrayAsInParam(mediumPropValues)));
907	}
908
909	if (fModifyCompact)
910	{
911	ComPtr<IProgress> pProgress;
912	CHECK_ERROR(pMedium, Compact(pProgress.asOutParam()));
913	if (SUCCEEDED(hrc))
914	hrc = showProgress(pProgress);
915	if (FAILED(hrc))
916	{
917	if (hrc == E_NOTIMPL)
918	RTMsgError(Disk::tr("Compact medium operation is not implemented!"));
919	else if (hrc == VBOX_E_NOT_SUPPORTED)
920	RTMsgError(Disk::tr("Compact medium operation for this format is not implemented yet!"));
921	else if (!pProgress.isNull())
922	CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to compact medium")));
923	else
924	RTMsgError(Disk::tr("Failed to compact medium!"));
925	}
926	}
927
928	if (fModifyResize)
929	{
930	ComPtr<IProgress> pProgress;
931	CHECK_ERROR(pMedium, Resize(cbResize, pProgress.asOutParam()));
932	if (SUCCEEDED(hrc))
933	hrc = showProgress(pProgress);
934	if (FAILED(hrc))
935	{
936	if (!pProgress.isNull())
937	CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to resize medium")));
938	else if (hrc == E_NOTIMPL)
939	RTMsgError(Disk::tr("Resize medium operation is not implemented!"));
940	else if (hrc == VBOX_E_NOT_SUPPORTED)
941	RTMsgError(Disk::tr("Resize medium operation for this format is not implemented yet!"));
942	else
943	RTMsgError(Disk::tr("Failed to resize medium!"));
944	}
945	}
946
947	if (fMoveMedium)
948	{
949	do
950	{
951	ComPtr<IProgress> pProgress;
952	Utf8Str strLocation(pszNewLocation);
953	RTStrFree(pszNewLocation);
954	CHECK_ERROR(pMedium, MoveTo(Bstr(strLocation).raw(), pProgress.asOutParam()));
955
956	if (SUCCEEDED(hrc) && !pProgress.isNull())
957	{
958	hrc = showProgress(pProgress);
959	CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to move medium")));
960	}
961
962	Bstr uuid;
963	CHECK_ERROR_BREAK(pMedium, COMGETTER(Id)(uuid.asOutParam()));
964
965	RTPrintf(Disk::tr("Move medium with UUID %s finished\n"), Utf8Str(uuid).c_str());
966	}
967	while (0);
968	}
969
970	if (fSetNewLocation)
971	{
972	Utf8Str strLocation(pszNewLocation);
973	RTStrFree(pszNewLocation);
974	CHECK_ERROR(pMedium, COMSETTER(Location)(Bstr(strLocation).raw()));
975
976	Bstr uuid;
977	CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam()));
978	RTPrintf(Disk::tr("Set new location of medium with UUID %s finished\n"), Utf8Str(uuid).c_str());
979	}
980
981	if (fModifyDescription)
982	{
983	CHECK_ERROR(pMedium, COMSETTER(Description)(Bstr(pszNewLocation).raw()));
984
985	RTPrintf(Disk::tr("Medium description has been changed.\n"));
986	}
987
988	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
989	}
990
991	static const RTGETOPTDEF g_aCloneMediumOptions[] =
992	{
993	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
994	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
995	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
996	{ "--format", 'o', RTGETOPT_REQ_STRING },
997	{ "-format", 'o', RTGETOPT_REQ_STRING },
998	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
999	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
1000	{ "--existing", 'E', RTGETOPT_REQ_NOTHING },
1001	{ "--variant", 'm', RTGETOPT_REQ_STRING },
1002	{ "-variant", 'm', RTGETOPT_REQ_STRING },
1003	{ "--resize", 'r', RTGETOPT_REQ_UINT64 },
1004	};
1005
1006	RTEXITCODE handleCloneMedium(HandlerArg *a)
1007	{
1008	HRESULT hrc;
1009	int vrc;
1010	enum {
1011	CMD_NONE,
1012	CMD_DISK,
1013	CMD_DVD,
1014	CMD_FLOPPY
1015	} cmd = CMD_NONE;
1016	const char *pszSrc = NULL;
1017	const char *pszDst = NULL;
1018	Bstr format;
1019	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
1020	bool fExisting = false;
1021	bool fNeedResize = false;
1022	uint64_t cbResize = 0;
1023
1024	int c;
1025	RTGETOPTUNION ValueUnion;
1026	RTGETOPTSTATE GetState;
1027	// start at 0 because main() has hacked both the argc and argv given to us
1028	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneMediumOptions, RT_ELEMENTS(g_aCloneMediumOptions),
1029	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1030	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1031	{
1032	switch (c)
1033	{
1034	case 'd': // disk
1035	if (cmd != CMD_NONE)
1036	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1037	cmd = CMD_DISK;
1038	break;
1039
1040	case 'D': // DVD
1041	if (cmd != CMD_NONE)
1042	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1043	cmd = CMD_DVD;
1044	break;
1045
1046	case 'f': // floppy
1047	if (cmd != CMD_NONE)
1048	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1049	cmd = CMD_FLOPPY;
1050	break;
1051
1052	case 'o': // --format
1053	format = ValueUnion.psz;
1054	break;
1055
1056	case 'F': // --static
1057	{
1058	unsigned uMediumVariant = (unsigned)enmMediumVariant;
1059	uMediumVariant \|= MediumVariant_Fixed;
1060	enmMediumVariant = (MediumVariant_T)uMediumVariant;
1061	break;
1062	}
1063
1064	case 'E': // --existing
1065	fExisting = true;
1066	break;
1067
1068	case 'm': // --variant
1069	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
1070	if (RT_FAILURE(vrc))
1071	return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
1072	break;
1073
1074	case 'r': // --resize
1075	fNeedResize = true;
1076	cbResize = ValueUnion.u64 * _1M;
1077	break;
1078
1079	case VINF_GETOPT_NOT_OPTION:
1080	if (!pszSrc)
1081	pszSrc = ValueUnion.psz;
1082	else if (!pszDst)
1083	pszDst = ValueUnion.psz;
1084	else
1085	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
1086	break;
1087
1088	default:
1089	if (c > 0)
1090	{
1091	if (RT_C_IS_GRAPH(c))
1092	return errorSyntax(Disk::tr("unhandled option: -%c"), c);
1093	else
1094	return errorSyntax(Disk::tr("unhandled option: %i"), c);
1095	}
1096	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1097	return errorSyntax(Disk::tr("unknown option: %s"), ValueUnion.psz);
1098	else if (ValueUnion.pDef)
1099	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
1100	else
1101	return errorSyntax(Disk::tr("error: %Rrs"), c);
1102	}
1103	}
1104
1105	if (cmd == CMD_NONE)
1106	cmd = CMD_DISK;
1107	if (!pszSrc)
1108	return errorSyntax(Disk::tr("Mandatory UUID or input file parameter missing"));
1109	if (!pszDst)
1110	return errorSyntax(Disk::tr("Mandatory output file parameter missing"));
1111	if (fExisting && (!format.isEmpty() \|\| enmMediumVariant != MediumVariant_Standard))
1112	return errorSyntax(Disk::tr("Specified options which cannot be used with --existing"));
1113
1114	ComPtr<IMedium> pSrcMedium;
1115	ComPtr<IMedium> pDstMedium;
1116
1117	if (cmd == CMD_DISK)
1118	hrc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium,
1119	false /* fForceNewUuidOnOpen /, false / fSilent */);
1120	else if (cmd == CMD_DVD)
1121	hrc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium,
1122	false /* fForceNewUuidOnOpen /, false / fSilent */);
1123	else if (cmd == CMD_FLOPPY)
1124	hrc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium,
1125	false /* fForceNewUuidOnOpen /, false / fSilent */);
1126	else
1127	hrc = E_INVALIDARG; /* cannot happen but make gcc happy */
1128	if (FAILED(hrc))
1129	return RTEXITCODE_FAILURE;
1130
1131	do
1132	{
1133	/* open/create destination medium */
1134	if (fExisting)
1135	{
1136	if (cmd == CMD_DISK)
1137	hrc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium,
1138	false /* fForceNewUuidOnOpen /, false / fSilent */);
1139	else if (cmd == CMD_DVD)
1140	hrc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium,
1141	false /* fForceNewUuidOnOpen /, false / fSilent */);
1142	else if (cmd == CMD_FLOPPY)
1143	hrc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium,
1144	false /* fForceNewUuidOnOpen /, false / fSilent */);
1145	if (FAILED(hrc))
1146	break;
1147
1148	/* Perform accessibility check now. */
1149	MediumState_T state;
1150	CHECK_ERROR_BREAK(pDstMedium, RefreshState(&state));
1151	CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Format)(format.asOutParam()));
1152	}
1153	else
1154	{
1155	/*
1156	* In case the format is unspecified check that the source medium supports
1157	* image creation and use the same format for the destination image.
1158	* Use the default image format if it is not supported.
1159	*/
1160	if (format.isEmpty())
1161	{
1162	ComPtr<IMediumFormat> pMediumFmt;
1163	com::SafeArray<MediumFormatCapabilities_T> l_caps;
1164	CHECK_ERROR_BREAK(pSrcMedium, COMGETTER(MediumFormat)(pMediumFmt.asOutParam()));
1165	CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Capabilities)(ComSafeArrayAsOutParam(l_caps)));
1166	ULONG caps=0;
1167	for (size_t i = 0; i < l_caps.size(); i++)
1168	caps \|= l_caps[i];
1169	if (caps & ( MediumFormatCapabilities_CreateDynamic
1170	\| MediumFormatCapabilities_CreateFixed))
1171	CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Id)(format.asOutParam()));
1172	}
1173	Utf8Str strFormat(format);
1174	if (cmd == CMD_DISK)
1175	hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk,
1176	AccessMode_ReadWrite, pDstMedium);
1177	else if (cmd == CMD_DVD)
1178	hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD,
1179	AccessMode_ReadOnly, pDstMedium);
1180	else if (cmd == CMD_FLOPPY)
1181	hrc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy,
1182	AccessMode_ReadWrite, pDstMedium);
1183	if (FAILED(hrc))
1184	break;
1185	}
1186
1187	ComPtr<IProgress> pProgress;
1188	com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
1189
1190	for (ULONG i = 0; i < l_variants.size(); ++i)
1191	{
1192	ULONG temp = enmMediumVariant;
1193	temp &= 1<<i;
1194	l_variants [i] = (MediumVariant_T)temp;
1195	}
1196
1197	if (fNeedResize)
1198	{
1199	CHECK_ERROR_BREAK(pSrcMedium, ResizeAndCloneTo(pDstMedium, cbResize, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
1200	}
1201	else
1202	{
1203	CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam()));
1204	}
1205
1206
1207	hrc = showProgress(pProgress);
1208	CHECK_PROGRESS_ERROR_BREAK(pProgress, (Disk::tr("Failed to clone medium")));
1209
1210	Bstr uuid;
1211	CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Id)(uuid.asOutParam()));
1212
1213	RTPrintf(Disk::tr("Clone medium created in format '%ls'. UUID: %s\n"),
1214	format.raw(), Utf8Str(uuid).c_str());
1215	}
1216	while (0);
1217
1218	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1219	}
1220
1221	static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] =
1222	{
1223	{ "--format", 'o', RTGETOPT_REQ_STRING },
1224	{ "-format", 'o', RTGETOPT_REQ_STRING },
1225	{ "--static", 'F', RTGETOPT_REQ_NOTHING },
1226	{ "-static", 'F', RTGETOPT_REQ_NOTHING },
1227	{ "--variant", 'm', RTGETOPT_REQ_STRING },
1228	{ "-variant", 'm', RTGETOPT_REQ_STRING },
1229	{ "--uuid", 'u', RTGETOPT_REQ_STRING },
1230	};
1231
1232	RTEXITCODE handleConvertFromRaw(HandlerArg *a)
1233	{
1234	bool fReadFromStdIn = false;
1235	const char *format = "VDI";
1236	const char *srcfilename = NULL;
1237	const char *dstfilename = NULL;
1238	const char *filesize = NULL;
1239	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1240	void *pvBuf = NULL;
1241	RTUUID uuid;
1242	PCRTUUID pUuid = NULL;
1243
1244	int c;
1245	RTGETOPTUNION ValueUnion;
1246	RTGETOPTSTATE GetState;
1247	// start at 0 because main() has hacked both the argc and argv given to us
1248	int vrc = RTGetOptInit(&GetState, a->argc, a->argv,
1249	g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions),
1250	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1251	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
1252	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1253	{
1254	switch (c)
1255	{
1256	case 'u': // --uuid
1257	if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz)))
1258	return errorSyntax(Disk::tr("Invalid UUID '%s'"), ValueUnion.psz);
1259	pUuid = &uuid;
1260	break;
1261	case 'o': // --format
1262	format = ValueUnion.psz;
1263	break;
1264
1265	case 'm': // --variant
1266	{
1267	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
1268	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
1269	if (RT_FAILURE(vrc))
1270	return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
1271	/// @todo cleaner solution than assuming 1:1 mapping?
1272	uImageFlags = (unsigned)enmMediumVariant;
1273	break;
1274	}
1275	case VINF_GETOPT_NOT_OPTION:
1276	if (!srcfilename)
1277	{
1278	srcfilename = ValueUnion.psz;
1279	fReadFromStdIn = !strcmp(srcfilename, "stdin");
1280	}
1281	else if (!dstfilename)
1282	dstfilename = ValueUnion.psz;
1283	else if (fReadFromStdIn && !filesize)
1284	filesize = ValueUnion.psz;
1285	else
1286	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
1287	break;
1288
1289	default:
1290	return errorGetOpt(c, &ValueUnion);
1291	}
1292	}
1293
1294	if (!srcfilename \|\| !dstfilename \|\| (fReadFromStdIn && !filesize))
1295	return errorSyntax(Disk::tr("Incorrect number of parameters"));
1296	RTStrmPrintf(g_pStdErr, Disk::tr("Converting from raw image file=\"%s\" to file=\"%s\"...\n"),
1297	srcfilename, dstfilename);
1298
1299	PVDISK pDisk = NULL;
1300
1301	PVDINTERFACE pVDIfs = NULL;
1302	VDINTERFACEERROR vdInterfaceError;
1303	vdInterfaceError.pfnError = handleVDError;
1304	vdInterfaceError.pfnMessage = NULL;
1305
1306	vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1307	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
1308	AssertRC(vrc);
1309
1310	/* open raw image file. */
1311	RTFILE File;
1312	if (fReadFromStdIn)
1313	vrc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN);
1314	else
1315	vrc = RTFileOpen(&File, srcfilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1316	if (RT_FAILURE(vrc))
1317	{
1318	RTMsgError(Disk::tr("Cannot open file \"%s\": %Rrc"), srcfilename, vrc);
1319	goto out;
1320	}
1321
1322	uint64_t cbFile;
1323	/* get image size. */
1324	if (fReadFromStdIn)
1325	cbFile = RTStrToUInt64(filesize);
1326	else
1327	vrc = RTFileQuerySize(File, &cbFile);
1328	if (RT_FAILURE(vrc))
1329	{
1330	RTMsgError(Disk::tr("Cannot get image size for file \"%s\": %Rrc"), srcfilename, vrc);
1331	goto out;
1332	}
1333
1334	RTStrmPrintf(g_pStdErr, Disk::tr("Creating %s image with size %RU64 bytes (%RU64MB)...\n", "", cbFile),
1335	(uImageFlags & VD_IMAGE_FLAGS_FIXED) ? Disk::tr("fixed", "adjective") : Disk::tr("dynamic", "adjective"),
1336	cbFile, (cbFile + _1M - 1) / _1M);
1337	char pszComment[256];
1338	RTStrPrintf(pszComment, sizeof(pszComment), Disk::tr("Converted image from %s"), srcfilename);
1339	vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1340	if (RT_FAILURE(vrc))
1341	{
1342	RTMsgError(Disk::tr("Cannot create the virtual disk container: %Rrc"), vrc);
1343	goto out;
1344	}
1345
1346	Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) -
1347	(unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0);
1348	VDGEOMETRY PCHS, LCHS;
1349	PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383);
1350	PCHS.cHeads = 16;
1351	PCHS.cSectors = 63;
1352	LCHS.cCylinders = 0;
1353	LCHS.cHeads = 0;
1354	LCHS.cSectors = 0;
1355	vrc = VDCreateBase(pDisk, format, dstfilename, cbFile,
1356	uImageFlags, pszComment, &PCHS, &LCHS, pUuid,
1357	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1358	if (RT_FAILURE(vrc))
1359	{
1360	RTMsgError(Disk::tr("Cannot create the disk image \"%s\": %Rrc"), dstfilename, vrc);
1361	goto out;
1362	}
1363
1364	size_t cbBuffer;
1365	cbBuffer = _1M;
1366	pvBuf = RTMemAlloc(cbBuffer);
1367	if (!pvBuf)
1368	{
1369	vrc = VERR_NO_MEMORY;
1370	RTMsgError(Disk::tr("Out of memory allocating buffers for image \"%s\": %Rrc"), dstfilename, vrc);
1371	goto out;
1372	}
1373
1374	uint64_t offFile;
1375	offFile = 0;
1376	while (offFile < cbFile)
1377	{
1378	size_t cbRead;
1379	size_t cbToRead;
1380	cbRead = 0;
1381	cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ?
1382	cbBuffer : (size_t)(cbFile - offFile);
1383	vrc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
1384	if (RT_FAILURE(vrc) \|\| !cbRead)
1385	break;
1386	vrc = VDWrite(pDisk, offFile, pvBuf, cbRead);
1387	if (RT_FAILURE(vrc))
1388	{
1389	RTMsgError(Disk::tr("Failed to write to disk image \"%s\": %Rrc"), dstfilename, vrc);
1390	goto out;
1391	}
1392	offFile += cbRead;
1393	}
1394
1395	out:
1396	if (pvBuf)
1397	RTMemFree(pvBuf);
1398	if (pDisk)
1399	VDClose(pDisk, RT_FAILURE(vrc));
1400	if (File != NIL_RTFILE)
1401	RTFileClose(File);
1402
1403	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1404	}
1405
1406	HRESULT showMediumInfo(const ComPtr<IVirtualBox> &pVirtualBox,
1407	const ComPtr<IMedium> &pMedium,
1408	const char *pszParentUUID,
1409	bool fOptLong)
1410	{
1411	HRESULT hrc = S_OK;
1412	do
1413	{
1414	Bstr uuid;
1415	pMedium->COMGETTER(Id)(uuid.asOutParam());
1416	RTPrintf("UUID: %ls\n", uuid.raw());
1417	if (pszParentUUID)
1418	RTPrintf(Disk::tr("Parent UUID: %s\n"), pszParentUUID);
1419
1420	/* check for accessibility */
1421	MediumState_T enmState;
1422	CHECK_ERROR_BREAK(pMedium, RefreshState(&enmState));
1423	const char *pszState = Disk::tr("unknown");
1424	switch (enmState)
1425	{
1426	case MediumState_NotCreated:
1427	pszState = Disk::tr("not created");
1428	break;
1429	case MediumState_Created:
1430	pszState = Disk::tr("created");
1431	break;
1432	case MediumState_LockedRead:
1433	pszState = Disk::tr("locked read");
1434	break;
1435	case MediumState_LockedWrite:
1436	pszState = Disk::tr("locked write");
1437	break;
1438	case MediumState_Inaccessible:
1439	pszState = Disk::tr("inaccessible");
1440	break;
1441	case MediumState_Creating:
1442	pszState = Disk::tr("creating");
1443	break;
1444	case MediumState_Deleting:
1445	pszState = Disk::tr("deleting");
1446	break;
1447	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1448	case MediumState_32BitHack: break; /* Shut up compiler warnings. */
1449	#endif
1450	}
1451	RTPrintf(Disk::tr("State: %s\n"), pszState);
1452
1453	if (fOptLong && enmState == MediumState_Inaccessible)
1454	{
1455	Bstr err;
1456	CHECK_ERROR_BREAK(pMedium, COMGETTER(LastAccessError)(err.asOutParam()));
1457	RTPrintf(Disk::tr("Access Error: %ls\n"), err.raw());
1458	}
1459
1460	if (fOptLong)
1461	{
1462	Bstr description;
1463	pMedium->COMGETTER(Description)(description.asOutParam());
1464	if (!description.isEmpty())
1465	RTPrintf(Disk::tr("Description: %ls\n"), description.raw());
1466	}
1467
1468	MediumType_T type;
1469	pMedium->COMGETTER(Type)(&type);
1470	const char *typeStr = Disk::tr("unknown");
1471	switch (type)
1472	{
1473	case MediumType_Normal:
1474	if (pszParentUUID && Guid(pszParentUUID).isValid())
1475	typeStr = Disk::tr("normal (differencing)");
1476	else
1477	typeStr = Disk::tr("normal (base)");
1478	break;
1479	case MediumType_Immutable:
1480	typeStr = Disk::tr("immutable");
1481	break;
1482	case MediumType_Writethrough:
1483	typeStr = Disk::tr("writethrough");
1484	break;
1485	case MediumType_Shareable:
1486	typeStr = Disk::tr("shareable");
1487	break;
1488	case MediumType_Readonly:
1489	typeStr = Disk::tr("readonly");
1490	break;
1491	case MediumType_MultiAttach:
1492	typeStr = Disk::tr("multiattach");
1493	break;
1494	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1495	case MediumType_32BitHack: break; /* Shut up compiler warnings. */
1496	#endif
1497	}
1498	RTPrintf(Disk::tr("Type: %s\n"), typeStr);
1499
1500	/* print out information specific for differencing media */
1501	if (fOptLong && pszParentUUID && Guid(pszParentUUID).isValid())
1502	{
1503	BOOL autoReset = FALSE;
1504	pMedium->COMGETTER(AutoReset)(&autoReset);
1505	RTPrintf(Disk::tr("Auto-Reset: %s\n"), autoReset ? Disk::tr("on") : Disk::tr("off"));
1506	}
1507
1508	Bstr loc;
1509	pMedium->COMGETTER(Location)(loc.asOutParam());
1510	RTPrintf(Disk::tr("Location: %ls\n"), loc.raw());
1511
1512	Bstr format;
1513	pMedium->COMGETTER(Format)(format.asOutParam());
1514	RTPrintf(Disk::tr("Storage format: %ls\n"), format.raw());
1515
1516	if (fOptLong)
1517	{
1518	com::SafeArray<MediumVariant_T> safeArray_variant;
1519
1520	pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(safeArray_variant));
1521	ULONG variant=0;
1522	for (size_t i = 0; i < safeArray_variant.size(); i++)
1523	variant \|= safeArray_variant[i];
1524
1525	const char *variantStr = Disk::tr("unknown");
1526	switch (variant & ~(MediumVariant_Fixed \| MediumVariant_Diff))
1527	{
1528	case MediumVariant_VmdkSplit2G:
1529	variantStr = Disk::tr("split2G");
1530	break;
1531	case MediumVariant_VmdkStreamOptimized:
1532	variantStr = Disk::tr("streamOptimized");
1533	break;
1534	case MediumVariant_VmdkESX:
1535	variantStr = Disk::tr("ESX");
1536	break;
1537	case MediumVariant_Standard:
1538	variantStr = Disk::tr("default");
1539	break;
1540	}
1541	const char *variantTypeStr = Disk::tr("dynamic");
1542	if (variant & MediumVariant_Fixed)
1543	variantTypeStr = Disk::tr("fixed");
1544	else if (variant & MediumVariant_Diff)
1545	variantTypeStr = Disk::tr("differencing");
1546	RTPrintf(Disk::tr("Format variant: %s %s\n"), variantTypeStr, variantStr);
1547	}
1548
1549	LONG64 logicalSize;
1550	pMedium->COMGETTER(LogicalSize)(&logicalSize);
1551	RTPrintf(Disk::tr("Capacity: %lld MBytes\n"), logicalSize >> 20);
1552	if (fOptLong)
1553	{
1554	LONG64 actualSize;
1555	pMedium->COMGETTER(Size)(&actualSize);
1556	RTPrintf(Disk::tr("Size on disk: %lld MBytes\n"), actualSize >> 20);
1557	}
1558
1559	Bstr strCipher;
1560	Bstr strPasswordId;
1561	HRESULT hrc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam());
1562	if (SUCCEEDED(hrc2))
1563	{
1564	RTPrintf(Disk::tr("Encryption: enabled\n"));
1565	if (fOptLong)
1566	{
1567	RTPrintf(Disk::tr("Cipher: %ls\n"), strCipher.raw());
1568	RTPrintf(Disk::tr("Password ID: %ls\n"), strPasswordId.raw());
1569	}
1570	}
1571	else
1572	RTPrintf(Disk::tr("Encryption: disabled\n"));
1573
1574	if (fOptLong)
1575	{
1576	com::SafeArray<BSTR> names;
1577	com::SafeArray<BSTR> values;
1578	pMedium->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1579	size_t cNames = names.size();
1580	size_t cValues = values.size();
1581	bool fFirst = true;
1582	for (size_t i = 0; i < cNames; i++)
1583	{
1584	Bstr value;
1585	if (i < cValues)
1586	value = values[i];
1587	RTPrintf("%s%ls=%ls\n",
1588	fFirst ? Disk::tr("Property: ") : " ",
1589	names[i], value.raw());
1590	fFirst = false;
1591	}
1592	}
1593
1594	if (fOptLong)
1595	{
1596	bool fFirst = true;
1597	com::SafeArray<BSTR> machineIds;
1598	pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
1599	for (size_t i = 0; i < machineIds.size(); i++)
1600	{
1601	ComPtr<IMachine> pMachine;
1602	CHECK_ERROR(pVirtualBox, FindMachine(machineIds[i], pMachine.asOutParam()));
1603	if (pMachine)
1604	{
1605	Bstr name;
1606	pMachine->COMGETTER(Name)(name.asOutParam());
1607	pMachine->COMGETTER(Id)(uuid.asOutParam());
1608	RTPrintf("%s%ls (UUID: %ls)",
1609	fFirst ? Disk::tr("In use by VMs: ") : " ",
1610	name.raw(), machineIds[i]);
1611	fFirst = false;
1612	com::SafeArray<BSTR> snapshotIds;
1613	pMedium->GetSnapshotIds(machineIds[i],
1614	ComSafeArrayAsOutParam(snapshotIds));
1615	for (size_t j = 0; j < snapshotIds.size(); j++)
1616	{
1617	ComPtr<ISnapshot> pSnapshot;
1618	pMachine->FindSnapshot(snapshotIds[j], pSnapshot.asOutParam());
1619	if (pSnapshot)
1620	{
1621	Bstr snapshotName;
1622	pSnapshot->COMGETTER(Name)(snapshotName.asOutParam());
1623	RTPrintf(" [%ls (UUID: %ls)]", snapshotName.raw(), snapshotIds[j]);
1624	}
1625	}
1626	RTPrintf("\n");
1627	}
1628	}
1629	}
1630
1631	if (fOptLong)
1632	{
1633	com::SafeIfaceArray<IMedium> children;
1634	pMedium->COMGETTER(Children)(ComSafeArrayAsOutParam(children));
1635	bool fFirst = true;
1636	for (size_t i = 0; i < children.size(); i++)
1637	{
1638	ComPtr<IMedium> pChild(children[i]);
1639	if (pChild)
1640	{
1641	Bstr childUUID;
1642	pChild->COMGETTER(Id)(childUUID.asOutParam());
1643	RTPrintf("%s%ls\n",
1644	fFirst ? Disk::tr("Child UUIDs: ") : " ",
1645	childUUID.raw());
1646	fFirst = false;
1647	}
1648	}
1649	}
1650	}
1651	while (0);
1652
1653	return hrc;
1654	}
1655
1656	static const RTGETOPTDEF g_aShowMediumInfoOptions[] =
1657	{
1658	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1659	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1660	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1661	};
1662
1663	RTEXITCODE handleShowMediumInfo(HandlerArg *a)
1664	{
1665	enum {
1666	CMD_NONE,
1667	CMD_DISK,
1668	CMD_DVD,
1669	CMD_FLOPPY
1670	} cmd = CMD_NONE;
1671	const char *pszFilenameOrUuid = NULL;
1672
1673	int c;
1674	RTGETOPTUNION ValueUnion;
1675	RTGETOPTSTATE GetState;
1676	// start at 0 because main() has hacked both the argc and argv given to us
1677	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowMediumInfoOptions, RT_ELEMENTS(g_aShowMediumInfoOptions),
1678	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1679	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1680	{
1681	switch (c)
1682	{
1683	case 'd': // disk
1684	if (cmd != CMD_NONE)
1685	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1686	cmd = CMD_DISK;
1687	break;
1688
1689	case 'D': // DVD
1690	if (cmd != CMD_NONE)
1691	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1692	cmd = CMD_DVD;
1693	break;
1694
1695	case 'f': // floppy
1696	if (cmd != CMD_NONE)
1697	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1698	cmd = CMD_FLOPPY;
1699	break;
1700
1701	case VINF_GETOPT_NOT_OPTION:
1702	if (!pszFilenameOrUuid)
1703	pszFilenameOrUuid = ValueUnion.psz;
1704	else
1705	return errorSyntax(Disk::tr("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(Disk::tr("Invalid option -%c"), c);
1713	else
1714	return errorSyntax(Disk::tr("Invalid option case %i"), c);
1715	}
1716	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1717	return errorSyntax(Disk::tr("unknown option: %s\n"), ValueUnion.psz);
1718	else if (ValueUnion.pDef)
1719	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
1720	else
1721	return errorSyntax(Disk::tr("error: %Rrs"), c);
1722	}
1723	}
1724
1725	if (cmd == CMD_NONE)
1726	cmd = CMD_DISK;
1727
1728	/* check for required options */
1729	if (!pszFilenameOrUuid)
1730	return errorSyntax(Disk::tr("Medium name or UUID required"));
1731
1732	HRESULT hrc = S_OK; /* Prevents warning. */
1733
1734	ComPtr<IMedium> pMedium;
1735	if (cmd == CMD_DISK)
1736	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1737	AccessMode_ReadOnly, pMedium,
1738	false /* fForceNewUuidOnOpen /, false / fSilent */);
1739	else if (cmd == CMD_DVD)
1740	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1741	AccessMode_ReadOnly, pMedium,
1742	false /* fForceNewUuidOnOpen /, false / fSilent */);
1743	else if (cmd == CMD_FLOPPY)
1744	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1745	AccessMode_ReadOnly, pMedium,
1746	false /* fForceNewUuidOnOpen /, false / fSilent */);
1747	if (FAILED(hrc))
1748	return RTEXITCODE_FAILURE;
1749
1750	Utf8Str strParentUUID(Disk::tr("base"));
1751	ComPtr<IMedium> pParent;
1752	pMedium->COMGETTER(Parent)(pParent.asOutParam());
1753	if (!pParent.isNull())
1754	{
1755	Bstr bstrParentUUID;
1756	pParent->COMGETTER(Id)(bstrParentUUID.asOutParam());
1757	strParentUUID = bstrParentUUID;
1758	}
1759
1760	hrc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true);
1761
1762	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1763	}
1764
1765	static const RTGETOPTDEF g_aCloseMediumOptions[] =
1766	{
1767	{ "disk", 'd', RTGETOPT_REQ_NOTHING },
1768	{ "dvd", 'D', RTGETOPT_REQ_NOTHING },
1769	{ "floppy", 'f', RTGETOPT_REQ_NOTHING },
1770	{ "--delete", 'r', RTGETOPT_REQ_NOTHING },
1771	};
1772
1773	RTEXITCODE handleCloseMedium(HandlerArg *a)
1774	{
1775	HRESULT hrc = S_OK;
1776	enum {
1777	CMD_NONE,
1778	CMD_DISK,
1779	CMD_DVD,
1780	CMD_FLOPPY
1781	} cmd = CMD_NONE;
1782	const char *pszFilenameOrUuid = NULL;
1783	bool fDelete = false;
1784
1785	int c;
1786	RTGETOPTUNION ValueUnion;
1787	RTGETOPTSTATE GetState;
1788	// start at 0 because main() has hacked both the argc and argv given to us
1789	RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions),
1790	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1791	while ((c = RTGetOpt(&GetState, &ValueUnion)))
1792	{
1793	switch (c)
1794	{
1795	case 'd': // disk
1796	if (cmd != CMD_NONE)
1797	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1798	cmd = CMD_DISK;
1799	break;
1800
1801	case 'D': // DVD
1802	if (cmd != CMD_NONE)
1803	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1804	cmd = CMD_DVD;
1805	break;
1806
1807	case 'f': // floppy
1808	if (cmd != CMD_NONE)
1809	return errorSyntax(Disk::tr("Only one command can be specified: '%s'"), ValueUnion.psz);
1810	cmd = CMD_FLOPPY;
1811	break;
1812
1813	case 'r': // --delete
1814	fDelete = true;
1815	break;
1816
1817	case VINF_GETOPT_NOT_OPTION:
1818	if (!pszFilenameOrUuid)
1819	pszFilenameOrUuid = ValueUnion.psz;
1820	else
1821	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
1822	break;
1823
1824	default:
1825	if (c > 0)
1826	{
1827	if (RT_C_IS_PRINT(c))
1828	return errorSyntax(Disk::tr("Invalid option -%c"), c);
1829	else
1830	return errorSyntax(Disk::tr("Invalid option case %i"), c);
1831	}
1832	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
1833	return errorSyntax(Disk::tr("unknown option: %s\n"), ValueUnion.psz);
1834	else if (ValueUnion.pDef)
1835	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
1836	else
1837	return errorSyntax(Disk::tr("error: %Rrs"), c);
1838	}
1839	}
1840
1841	/* check for required options */
1842	if (cmd == CMD_NONE)
1843	cmd = CMD_DISK;
1844	if (!pszFilenameOrUuid)
1845	return errorSyntax(Disk::tr("Medium name or UUID required"));
1846
1847	ComPtr<IMedium> pMedium;
1848	if (cmd == CMD_DISK)
1849	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1850	AccessMode_ReadWrite, pMedium,
1851	false /* fForceNewUuidOnOpen /, false / fSilent */);
1852	else if (cmd == CMD_DVD)
1853	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1854	AccessMode_ReadOnly, pMedium,
1855	false /* fForceNewUuidOnOpen /, false / fSilent */);
1856	else if (cmd == CMD_FLOPPY)
1857	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1858	AccessMode_ReadWrite, pMedium,
1859	false /* fForceNewUuidOnOpen /, false / fSilent */);
1860
1861	if (SUCCEEDED(hrc) && pMedium)
1862	{
1863	if (fDelete)
1864	{
1865	ComPtr<IProgress> pProgress;
1866	CHECK_ERROR(pMedium, DeleteStorage(pProgress.asOutParam()));
1867	if (SUCCEEDED(hrc))
1868	{
1869	hrc = showProgress(pProgress);
1870	CHECK_PROGRESS_ERROR(pProgress, (Disk::tr("Failed to delete medium")));
1871	}
1872	else
1873	RTMsgError(Disk::tr("Failed to delete medium. Error code %Rhrc"), hrc);
1874	}
1875	CHECK_ERROR(pMedium, Close());
1876	}
1877
1878	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1879	}
1880
1881	RTEXITCODE handleMediumProperty(HandlerArg *a)
1882	{
1883	HRESULT hrc = S_OK;
1884	const char *pszCmd = NULL;
1885	enum {
1886	CMD_NONE,
1887	CMD_DISK,
1888	CMD_DVD,
1889	CMD_FLOPPY
1890	} cmd = CMD_NONE;
1891	const char *pszAction = NULL;
1892	const char *pszFilenameOrUuid = NULL;
1893	const char *pszProperty = NULL;
1894	ComPtr<IMedium> pMedium;
1895
1896	pszCmd = (a->argc > 0) ? a->argv[0] : "";
1897	if ( !RTStrICmp(pszCmd, "disk")
1898	\|\| !RTStrICmp(pszCmd, "dvd")
1899	\|\| !RTStrICmp(pszCmd, "floppy"))
1900	{
1901	if (!RTStrICmp(pszCmd, "disk"))
1902	cmd = CMD_DISK;
1903	else if (!RTStrICmp(pszCmd, "dvd"))
1904	cmd = CMD_DVD;
1905	else if (!RTStrICmp(pszCmd, "floppy"))
1906	cmd = CMD_FLOPPY;
1907	else
1908	{
1909	AssertMsgFailed((Disk::tr("unexpected parameter %s\n"), pszCmd));
1910	cmd = CMD_DISK;
1911	}
1912	a->argv++;
1913	a->argc--;
1914	}
1915	else
1916	{
1917	pszCmd = NULL;
1918	cmd = CMD_DISK;
1919	}
1920
1921	if (a->argc == 0)
1922	return errorSyntax(Disk::tr("Missing action"));
1923
1924	pszAction = a->argv[0];
1925	if ( RTStrICmp(pszAction, "set")
1926	&& RTStrICmp(pszAction, "get")
1927	&& RTStrICmp(pszAction, "delete"))
1928	return errorSyntax(Disk::tr("Invalid action given: %s"), pszAction);
1929
1930	if ( ( !RTStrICmp(pszAction, "set")
1931	&& a->argc != 4)
1932	\|\| ( RTStrICmp(pszAction, "set")
1933	&& a->argc != 3))
1934	return errorSyntax(Disk::tr("Invalid number of arguments given for action: %s"), pszAction);
1935
1936	pszFilenameOrUuid = a->argv[1];
1937	pszProperty = a->argv[2];
1938
1939	if (cmd == CMD_DISK)
1940	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
1941	AccessMode_ReadWrite, pMedium,
1942	false /* fForceNewUuidOnOpen /, false / fSilent */);
1943	else if (cmd == CMD_DVD)
1944	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD,
1945	AccessMode_ReadOnly, pMedium,
1946	false /* fForceNewUuidOnOpen /, false / fSilent */);
1947	else if (cmd == CMD_FLOPPY)
1948	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy,
1949	AccessMode_ReadWrite, pMedium,
1950	false /* fForceNewUuidOnOpen /, false / fSilent */);
1951	if (SUCCEEDED(hrc) && !pMedium.isNull())
1952	{
1953	if (!RTStrICmp(pszAction, "set"))
1954	{
1955	const char *pszValue = a->argv[3];
1956	CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr(pszValue).raw()));
1957	}
1958	else if (!RTStrICmp(pszAction, "get"))
1959	{
1960	/*
1961	* Trigger a call to Medium::i_queryInfo()->VDOpen()->pfnOpen() to
1962	* open the virtual device and populate its properties for
1963	* Medium::getProperty() to retrieve.
1964	*/
1965	MediumState_T state;
1966	CHECK_ERROR(pMedium, RefreshState(&state));
1967
1968	Bstr strVal;
1969	CHECK_ERROR(pMedium, GetProperty(Bstr(pszProperty).raw(), strVal.asOutParam()));
1970	if (SUCCEEDED(hrc))
1971	RTPrintf("%s=%ls\n", pszProperty, strVal.raw());
1972	}
1973	else if (!RTStrICmp(pszAction, "delete"))
1974	{
1975	CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr().raw()));
1976	/** @todo */
1977	}
1978	}
1979
1980	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1981	}
1982
1983	static const RTGETOPTDEF g_aEncryptMediumOptions[] =
1984	{
1985	{ "--newpassword", 'n', RTGETOPT_REQ_STRING },
1986	{ "--oldpassword", 'o', RTGETOPT_REQ_STRING },
1987	{ "--cipher", 'c', RTGETOPT_REQ_STRING },
1988	{ "--newpasswordid", 'i', RTGETOPT_REQ_STRING }
1989	};
1990
1991	RTEXITCODE handleEncryptMedium(HandlerArg *a)
1992	{
1993	HRESULT hrc;
1994	ComPtr<IMedium> hardDisk;
1995	const char *pszPasswordNew = NULL;
1996	const char *pszPasswordOld = NULL;
1997	const char *pszCipher = NULL;
1998	const char *pszFilenameOrUuid = NULL;
1999	const char *pszNewPasswordId = NULL;
2000	Utf8Str strPasswordNew;
2001	Utf8Str strPasswordOld;
2002
2003	int c;
2004	RTGETOPTUNION ValueUnion;
2005	RTGETOPTSTATE GetState;
2006	// start at 0 because main() has hacked both the argc and argv given to us
2007	RTGetOptInit(&GetState, a->argc, a->argv, g_aEncryptMediumOptions, RT_ELEMENTS(g_aEncryptMediumOptions),
2008	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
2009	while ((c = RTGetOpt(&GetState, &ValueUnion)))
2010	{
2011	switch (c)
2012	{
2013	case 'n': // --newpassword
2014	pszPasswordNew = ValueUnion.psz;
2015	break;
2016
2017	case 'o': // --oldpassword
2018	pszPasswordOld = ValueUnion.psz;
2019	break;
2020
2021	case 'c': // --cipher
2022	pszCipher = ValueUnion.psz;
2023	break;
2024
2025	case 'i': // --newpasswordid
2026	pszNewPasswordId = ValueUnion.psz;
2027	break;
2028
2029	case VINF_GETOPT_NOT_OPTION:
2030	if (!pszFilenameOrUuid)
2031	pszFilenameOrUuid = ValueUnion.psz;
2032	else
2033	return errorSyntax(Disk::tr("Invalid parameter '%s'"), ValueUnion.psz);
2034	break;
2035
2036	default:
2037	if (c > 0)
2038	{
2039	if (RT_C_IS_PRINT(c))
2040	return errorSyntax(Disk::tr("Invalid option -%c"), c);
2041	else
2042	return errorSyntax(Disk::tr("Invalid option case %i"), c);
2043	}
2044	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
2045	return errorSyntax(Disk::tr("unknown option: %s\n"), ValueUnion.psz);
2046	else if (ValueUnion.pDef)
2047	return errorSyntax("%s: %Rrs", ValueUnion.pDef->pszLong, c);
2048	else
2049	return errorSyntax(Disk::tr("error: %Rrs"), c);
2050	}
2051	}
2052
2053	if (!pszFilenameOrUuid)
2054	return errorSyntax(Disk::tr("Disk name or UUID required"));
2055
2056	if (!pszPasswordNew && !pszPasswordOld)
2057	return errorSyntax(Disk::tr("No password specified"));
2058
2059	if ( (pszPasswordNew && !pszNewPasswordId)
2060	\|\| (!pszPasswordNew && pszNewPasswordId))
2061	return errorSyntax(Disk::tr("A new password must always have a valid identifier set at the same time"));
2062
2063	if (pszPasswordNew)
2064	{
2065	if (!RTStrCmp(pszPasswordNew, "-"))
2066	{
2067	/* Get password from console. */
2068	RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, Disk::tr("Enter new password:"));
2069	if (rcExit == RTEXITCODE_FAILURE)
2070	return rcExit;
2071	}
2072	else
2073	{
2074	RTEXITCODE rcExit = readPasswordFile(pszPasswordNew, &strPasswordNew);
2075	if (rcExit == RTEXITCODE_FAILURE)
2076	{
2077	RTMsgError(Disk::tr("Failed to read new password from file"));
2078	return rcExit;
2079	}
2080	}
2081	}
2082
2083	if (pszPasswordOld)
2084	{
2085	if (!RTStrCmp(pszPasswordOld, "-"))
2086	{
2087	/* Get password from console. */
2088	RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, Disk::tr("Enter old password:"));
2089	if (rcExit == RTEXITCODE_FAILURE)
2090	return rcExit;
2091	}
2092	else
2093	{
2094	RTEXITCODE rcExit = readPasswordFile(pszPasswordOld, &strPasswordOld);
2095	if (rcExit == RTEXITCODE_FAILURE)
2096	{
2097	RTMsgError(Disk::tr("Failed to read old password from file"));
2098	return rcExit;
2099	}
2100	}
2101	}
2102
2103	/* Always open the medium if necessary, there is no other way. */
2104	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
2105	AccessMode_ReadWrite, hardDisk,
2106	false /* fForceNewUuidOnOpen /, false / fSilent */);
2107	if (FAILED(hrc))
2108	return RTEXITCODE_FAILURE;
2109	if (hardDisk.isNull())
2110	return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid hard disk reference, avoiding crash"));
2111
2112	ComPtr<IProgress> progress;
2113	CHECK_ERROR(hardDisk, ChangeEncryption(Bstr(strPasswordOld).raw(), Bstr(pszCipher).raw(),
2114	Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(),
2115	progress.asOutParam()));
2116	if (SUCCEEDED(hrc))
2117	hrc = showProgress(progress);
2118	if (FAILED(hrc))
2119	{
2120	if (hrc == E_NOTIMPL)
2121	RTMsgError(Disk::tr("Encrypt hard disk operation is not implemented!"));
2122	else if (hrc == VBOX_E_NOT_SUPPORTED)
2123	RTMsgError(Disk::tr("Encrypt hard disk operation for this cipher is not implemented yet!"));
2124	else if (!progress.isNull())
2125	CHECK_PROGRESS_ERROR(progress, (Disk::tr("Failed to encrypt hard disk")));
2126	else
2127	RTMsgError(Disk::tr("Failed to encrypt hard disk!"));
2128	}
2129
2130	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2131	}
2132
2133	RTEXITCODE handleCheckMediumPassword(HandlerArg *a)
2134	{
2135	HRESULT hrc;
2136	ComPtr<IMedium> hardDisk;
2137	const char *pszFilenameOrUuid = NULL;
2138	Utf8Str strPassword;
2139
2140	if (a->argc != 2)
2141	return errorSyntax(Disk::tr("Invalid number of arguments: %d"), a->argc);
2142
2143	pszFilenameOrUuid = a->argv[0];
2144
2145	if (!RTStrCmp(a->argv[1], "-"))
2146	{
2147	/* Get password from console. */
2148	RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, Disk::tr("Enter password:"));
2149	if (rcExit == RTEXITCODE_FAILURE)
2150	return rcExit;
2151	}
2152	else
2153	{
2154	RTEXITCODE rcExit = readPasswordFile(a->argv[1], &strPassword);
2155	if (rcExit == RTEXITCODE_FAILURE)
2156	{
2157	RTMsgError(Disk::tr("Failed to read password from file"));
2158	return rcExit;
2159	}
2160	}
2161
2162	/* Always open the medium if necessary, there is no other way. */
2163	hrc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk,
2164	AccessMode_ReadWrite, hardDisk,
2165	false /* fForceNewUuidOnOpen /, false / fSilent */);
2166	if (FAILED(hrc))
2167	return RTEXITCODE_FAILURE;
2168	if (hardDisk.isNull())
2169	return RTMsgErrorExit(RTEXITCODE_FAILURE, Disk::tr("Invalid hard disk reference, avoiding crash"));
2170
2171	CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw()));
2172	if (SUCCEEDED(hrc))
2173	RTPrintf(Disk::tr("The given password is correct\n"));
2174	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2175	}
2176
2177
2178	/*********************************************************************************************************************************
2179	* The mediumio command *
2180	*********************************************************************************************************************************/
2181
2182	/**
2183	* Common MediumIO options.
2184	*/
2185	typedef struct MEDIUMIOCOMMONOPT
2186	{
2187	const char *pszFilenameOrUuid;
2188	DeviceType_T enmDeviceType;
2189	const char *pszPasswordFile;
2190	} MEDIUMIOCOMMONOPT;
2191	typedef MEDIUMIOCOMMONOPT *PMEDIUMIOCOMMONOPT;
2192	typedef MEDIUMIOCOMMONOPT const *PCMEDIUMIOCOMMONOPT;
2193
2194	/* For RTGETOPTDEF array initializer. */
2195	#define MEDIUMIOCOMMONOPT_DEFS() \
2196	{ "--disk", 'd', RTGETOPT_REQ_STRING }, \
2197	{ "--harddisk", 'd', RTGETOPT_REQ_STRING }, \
2198	{ "disk", 'd', RTGETOPT_REQ_STRING }, \
2199	{ "harddisk", 'd', RTGETOPT_REQ_STRING }, \
2200	{ "--dvd", 'D', RTGETOPT_REQ_STRING }, \
2201	{ "--iso", 'D', RTGETOPT_REQ_STRING }, \
2202	{ "dvd", 'D', RTGETOPT_REQ_STRING }, \
2203	{ "iso", 'D', RTGETOPT_REQ_STRING }, \
2204	{ "--floppy", 'f', RTGETOPT_REQ_STRING }, \
2205	{ "floppy", 'f', RTGETOPT_REQ_STRING }, \
2206	{ "--password-file", 'P', RTGETOPT_REQ_STRING }
2207
2208	/* For option switch. */
2209	#define MEDIUMIOCOMMONOPT_CASES(a_pCommonOpts) \
2210	case 'd': \
2211	(a_pCommonOpts)->enmDeviceType = DeviceType_HardDisk; \
2212	(a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2213	break; \
2214	case 'D': \
2215	(a_pCommonOpts)->enmDeviceType = DeviceType_DVD; \
2216	(a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2217	break; \
2218	case 'f': \
2219	(a_pCommonOpts)->enmDeviceType = DeviceType_Floppy; \
2220	(a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \
2221	break; \
2222	case 'P': \
2223	(a_pCommonOpts)->pszPasswordFile = ValueUnion.psz; \
2224	break
2225
2226
2227	/**
2228	* Worker for mediumio operations that returns a IMediumIO for the specified
2229	* medium.
2230	*
2231	* @returns Exit code.
2232	* @param pHandler The handler state structure (for IVirtualBox).
2233	* @param pCommonOpts Common mediumio options.
2234	* @param fWritable Whether to open writable (true) or read only
2235	* (false).
2236	* @param rPtrMediumIO Where to return the IMediumIO pointer.
2237	* @param pcbMedium Where to return the meidum size. Optional.
2238	*/
2239	static RTEXITCODE mediumIOOpenMediumForIO(HandlerArg *pHandler, PCMEDIUMIOCOMMONOPT pCommonOpts, bool fWritable,
2240	ComPtr<IMediumIO> &rPtrMediumIO, uint64_t *pcbMedium = NULL)
2241	{
2242	/* Clear returns. */
2243	if (pcbMedium)
2244	*pcbMedium = 0;
2245	rPtrMediumIO.setNull();
2246
2247	/*
2248	* Make sure a medium was specified already.
2249	*/
2250	if (pCommonOpts->enmDeviceType == DeviceType_Null)
2251	return errorSyntax(Disk::tr("No medium specified!"));
2252
2253	/*
2254	* Read the password.
2255	*/
2256	Bstr bstrPassword;
2257	if (pCommonOpts->pszPasswordFile)
2258	{
2259	Utf8Str strPassword;
2260	RTEXITCODE rcExit;
2261	if (pCommonOpts->pszPasswordFile[0] == '-' && pCommonOpts->pszPasswordFile[1] == '\0')
2262	rcExit = readPasswordFromConsole(&strPassword, Disk::tr("Enter encryption password:"));
2263	else
2264	rcExit = readPasswordFile(pCommonOpts->pszPasswordFile, &strPassword);
2265	if (rcExit != RTEXITCODE_SUCCESS)
2266	return rcExit;
2267	bstrPassword = strPassword;
2268	strPassword.assign(strPassword.length(), '*');
2269	}
2270
2271	/*
2272	* Open the medium and then get I/O access to it.
2273	*/
2274	ComPtr<IMedium> ptrMedium;
2275	HRESULT hrc = openMedium(pHandler, pCommonOpts->pszFilenameOrUuid, pCommonOpts->enmDeviceType,
2276	fWritable ? AccessMode_ReadWrite : AccessMode_ReadOnly,
2277	ptrMedium, false /* fForceNewUuidOnOpen /, false / fSilent */);
2278	if (SUCCEEDED(hrc))
2279	{
2280	CHECK_ERROR2I_STMT(ptrMedium, OpenForIO(fWritable, bstrPassword.raw(), rPtrMediumIO.asOutParam()), hrc = hrcCheck);
2281
2282	/*
2283	* If the size is requested get it after we've opened it.
2284	*/
2285	if (pcbMedium && SUCCEEDED(hrc))
2286	{
2287	LONG64 cbLogical = 0;
2288	CHECK_ERROR2I_STMT(ptrMedium, COMGETTER(LogicalSize)(&cbLogical), hrc = hrcCheck);
2289	*pcbMedium = cbLogical;
2290	if (!SUCCEEDED(hrc))
2291	rPtrMediumIO.setNull();
2292	}
2293	}
2294
2295	if (bstrPassword.isNotEmpty())
2296	memset(bstrPassword.mutableRaw(), '', bstrPassword.length() sizeof(RTUTF16));
2297	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2298	}
2299
2300
2301	/**
2302	* mediumio formatfat
2303	*/
2304	static RTEXITCODE handleMediumIOFormatFat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2305	{
2306	/*
2307	* Parse the options.
2308	*/
2309	bool fQuick = false;
2310	static const RTGETOPTDEF s_aOptions[] =
2311	{
2312	MEDIUMIOCOMMONOPT_DEFS(),
2313	{ "--quick", 'q', RTGETOPT_REQ_NOTHING },
2314	};
2315
2316	RTGETOPTSTATE GetState;
2317	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2318	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2319	RTGETOPTUNION ValueUnion;
2320	while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2321	{
2322	switch (vrc)
2323	{
2324	MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2325
2326	case 'q':
2327	fQuick = true;
2328	break;
2329
2330	default:
2331	return errorGetOpt(vrc, &ValueUnion);
2332	}
2333	}
2334
2335	/*
2336	* Open the medium for I/O and format it.
2337	*/
2338	ComPtr<IMediumIO> ptrMediumIO;
2339	RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, true /fWritable/, ptrMediumIO);
2340	if (rcExit != RTEXITCODE_SUCCESS)
2341	return rcExit;
2342	CHECK_ERROR2I_RET(ptrMediumIO, FormatFAT(fQuick), RTEXITCODE_FAILURE);
2343	return RTEXITCODE_SUCCESS;
2344	}
2345
2346	/**
2347	* mediumio cat
2348	*/
2349	static RTEXITCODE handleMediumIOCat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2350	{
2351	/*
2352	* Parse the options.
2353	*/
2354	static const RTGETOPTDEF s_aOptions[] =
2355	{
2356	MEDIUMIOCOMMONOPT_DEFS(),
2357	{ "--hex", 'H', RTGETOPT_REQ_NOTHING },
2358	{ "--offset", 'o', RTGETOPT_REQ_UINT64 },
2359	{ "--output", 'O', RTGETOPT_REQ_STRING },
2360	{ "--size", 's', RTGETOPT_REQ_UINT64 },
2361	};
2362	bool fHex = false;
2363	uint64_t off = 0;
2364	const char *pszOutput = NULL;
2365	uint64_t cb = UINT64_MAX;
2366
2367	RTGETOPTSTATE GetState;
2368	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2369	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2370	RTGETOPTUNION ValueUnion;
2371	while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2372	{
2373	switch (vrc)
2374	{
2375	MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2376
2377	case 'H':
2378	fHex = true;
2379	break;
2380
2381	case 'o':
2382	off = ValueUnion.u64;
2383	break;
2384
2385	case 'O':
2386	pszOutput = ValueUnion.psz;
2387	break;
2388
2389	case 's':
2390	cb = ValueUnion.u64;
2391	break;
2392
2393	default:
2394	return errorGetOpt(vrc, &ValueUnion);
2395	}
2396	}
2397
2398	/*
2399	* Open the medium for I/O.
2400	*/
2401	ComPtr<IMediumIO> ptrMediumIO;
2402	uint64_t cbMedium;
2403	RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /fWritable/, ptrMediumIO, &cbMedium);
2404	if (rcExit == RTEXITCODE_SUCCESS)
2405	{
2406	/*
2407	* Do we have an output file or do we write to stdout?
2408	*/
2409	PRTSTREAM pOut = NULL;
2410	if (pszOutput && (pszOutput[0] != '-' \|\| pszOutput[1] != '\0'))
2411	{
2412	vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut);
2413	if (RT_FAILURE(vrc))
2414	rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
2415	}
2416	else
2417	{
2418	pOut = g_pStdOut;
2419	if (!fHex)
2420	RTStrmSetMode(pOut, true, -1);
2421	}
2422
2423	if (rcExit == RTEXITCODE_SUCCESS)
2424	{
2425	/*
2426	* Adjust 'cb' now that we've got the medium size.
2427	*/
2428	if (off >= cbMedium)
2429	{
2430	RTMsgWarning(Disk::tr("Specified offset (%#RX64) is beyond the end of the medium (%#RX64)"), off, cbMedium);
2431	cb = 0;
2432	}
2433	else if ( cb > cbMedium
2434	\|\| cb + off > cbMedium)
2435	cb = cbMedium - off;
2436
2437	/*
2438	* Hex dump preps. (The duplication detection is making ASSUMPTIONS about
2439	* all the reads being a multiple of cchWidth, except for the final one.)
2440	*/
2441	char abHexBuf[16] = { 0 };
2442	size_t cbHexBuf = 0;
2443	unsigned const cchWidth = RT_ELEMENTS(abHexBuf);
2444	uint64_t const offEndDupCheck = cb - cchWidth;
2445	uint64_t cDuplicates = 0;
2446
2447	/*
2448	* Do the reading.
2449	*/
2450	while (cb > 0)
2451	{
2452	char szLine[32 + cchWidth * 4 + 32];
2453
2454	/* Do the reading. */
2455	uint32_t const cbToRead = (uint32_t)RT_MIN(cb, _128K);
2456	SafeArray<BYTE> SafeArrayBuf;
2457	HRESULT hrc = ptrMediumIO->Read(off, cbToRead, ComSafeArrayAsOutParam(SafeArrayBuf));
2458	if (FAILED(hrc))
2459	{
2460	RTStrPrintf(szLine, sizeof(szLine), Disk::tr("Read(%zu bytes at %#RX64)", "", cbToRead), cbToRead, off);
2461	com::GlueHandleComError(ptrMediumIO, szLine, hrc, __FILE__, __LINE__);
2462	break;
2463	}
2464
2465	/* Output the data. */
2466	size_t const cbReturned = SafeArrayBuf.size();
2467	if (cbReturned)
2468	{
2469	BYTE const *pbBuf = SafeArrayBuf.raw();
2470	if (!fHex)
2471	vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
2472	else
2473	{
2474	/* hexdump -C */
2475	vrc = VINF_SUCCESS;
2476	uint64_t offHex = off;
2477	uint64_t const offHexEnd = off + cbReturned;
2478	while (offHex < offHexEnd)
2479	{
2480	if ( offHex >= offEndDupCheck
2481	\|\| cbHexBuf == 0
2482	\|\| memcmp(pbBuf, abHexBuf, cchWidth) != 0
2483	\|\| ( cDuplicates == 0
2484	&& ( offHex + cchWidth >= offEndDupCheck
2485	\|\| memcmp(pbBuf + cchWidth, pbBuf, cchWidth) != 0)) )
2486	{
2487	if (cDuplicates > 0)
2488	{
2489	RTStrmPrintf(pOut, Disk::tr("********** <ditto x %RU64>\n"), cDuplicates);
2490	cDuplicates = 0;
2491	}
2492
2493	size_t cch = RTStrPrintf(szLine, sizeof(szLine), "%012RX64:", offHex);
2494	unsigned i;
2495	for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++)
2496	{
2497	static const char s_szHexDigits[17] = "0123456789abcdef";
2498	szLine[cch++] = (i & 7) \|\| i == 0 ? ' ' : '-';
2499	uint8_t const u8 = pbBuf[i];
2500	szLine[cch++] = s_szHexDigits[u8 >> 4];
2501	szLine[cch++] = s_szHexDigits[u8 & 0xf];
2502	}
2503	while (i++ < cchWidth)
2504	{
2505	szLine[cch++] = ' ';
2506	szLine[cch++] = ' ';
2507	szLine[cch++] = ' ';
2508	}
2509	szLine[cch++] = ' ';
2510
2511	for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++)
2512	{
2513	uint8_t const u8 = pbBuf[i];
2514	szLine[cch++] = u8 < 127 && u8 >= 32 ? u8 : '.';
2515	}
2516	szLine[cch++] = '\n';
2517	szLine[cch] = '\0';
2518
2519	vrc = RTStrmWrite(pOut, szLine, cch);
2520	if (RT_FAILURE(vrc))
2521	break;
2522
2523
2524	/* copy bytes over to the duplication detection buffer. */
2525	cbHexBuf = (size_t)RT_MIN(cchWidth, offHexEnd - offHex);
2526	memcpy(abHexBuf, pbBuf, cbHexBuf);
2527	}
2528	else
2529	cDuplicates++;
2530
2531	/* Advance to next line. */
2532	pbBuf += cchWidth;
2533	offHex += cchWidth;
2534	}
2535	}
2536	if (RT_FAILURE(vrc))
2537	{
2538	rcExit = RTMsgErrorExitFailure(Disk::tr("Error writing to '%s': %Rrc"), pszOutput, vrc);
2539	break;
2540	}
2541	}
2542
2543	/* Advance. */
2544	if (cbReturned != cbToRead)
2545	{
2546	rcExit = RTMsgErrorExitFailure(Disk::tr("Expected read() at offset %RU64 (%#RX64) to return %#zx bytes, only got %#zx!\n",
2547	"", cbReturned),
2548	off, off, cbReturned, cbToRead);
2549	break;
2550	}
2551	off += cbReturned;
2552	cb -= cbReturned;
2553	}
2554
2555	/*
2556	* Close output.
2557	*/
2558	if (pOut != g_pStdOut)
2559	{
2560	vrc = RTStrmClose(pOut);
2561	if (RT_FAILURE(vrc))
2562	rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
2563	}
2564	else if (!fHex)
2565	RTStrmSetMode(pOut, false, -1);
2566	}
2567	}
2568	return rcExit;
2569	}
2570
2571	/**
2572	* mediumio stream
2573	*/
2574	static RTEXITCODE handleMediumIOStream(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts)
2575	{
2576	/*
2577	* Parse the options.
2578	*/
2579	static const RTGETOPTDEF s_aOptions[] =
2580	{
2581	MEDIUMIOCOMMONOPT_DEFS(),
2582	{ "--output", 'O', RTGETOPT_REQ_STRING },
2583	{ "--format", 'F', RTGETOPT_REQ_STRING },
2584	{ "--variant", 'v', RTGETOPT_REQ_STRING }
2585	};
2586	const char *pszOutput = NULL;
2587	MediumVariant_T enmMediumVariant = MediumVariant_Standard;
2588	Bstr strFormat;
2589
2590	RTGETOPTSTATE GetState;
2591	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0);
2592	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2593	RTGETOPTUNION ValueUnion;
2594	while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2595	{
2596	switch (vrc)
2597	{
2598	MEDIUMIOCOMMONOPT_CASES(pCommonOpts);
2599
2600	case 'O':
2601	pszOutput = ValueUnion.psz;
2602	break;
2603	case 'F':
2604	strFormat = ValueUnion.psz;
2605	break;
2606	case 'v': // --variant
2607	{
2608	vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant);
2609	if (RT_FAILURE(vrc))
2610	return errorArgument(Disk::tr("Invalid medium variant '%s'"), ValueUnion.psz);
2611	break;
2612	}
2613
2614	default:
2615	return errorGetOpt(vrc, &ValueUnion);
2616	}
2617	}
2618
2619	/*
2620	* Open the medium for I/O.
2621	*/
2622	ComPtr<IMediumIO> ptrMediumIO;
2623	uint64_t cbMedium;
2624	RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /fWritable/, ptrMediumIO, &cbMedium);
2625	if (rcExit == RTEXITCODE_SUCCESS)
2626	{
2627	/*
2628	* Do we have an output file or do we write to stdout?
2629	*/
2630	PRTSTREAM pOut = NULL;
2631	if (pszOutput && (pszOutput[0] != '-' \|\| pszOutput[1] != '\0'))
2632	{
2633	vrc = RTStrmOpen(pszOutput, "wb", &pOut);
2634	if (RT_FAILURE(vrc))
2635	rcExit = RTMsgErrorExitFailure(Disk::tr("Error opening '%s' for writing: %Rrc"), pszOutput, vrc);
2636	}
2637	else
2638	{
2639	pOut = g_pStdOut;
2640	RTStrmSetMode(pOut, true, -1);
2641	}
2642
2643	if (rcExit == RTEXITCODE_SUCCESS)
2644	{
2645	ComPtr<IDataStream> ptrDataStream;
2646	ComPtr<IProgress> ptrProgress;
2647
2648	com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
2649
2650	for (ULONG i = 0; i < l_variants.size(); ++i)
2651	{
2652	ULONG temp = enmMediumVariant;
2653	temp &= 1<<i;
2654	l_variants [i] = (MediumVariant_T)temp;
2655	}
2656
2657	HRESULT hrc = ptrMediumIO->ConvertToStream(strFormat.raw(), ComSafeArrayAsInParam(l_variants), 10 * _1M, ptrDataStream.asOutParam(), ptrProgress.asOutParam());
2658	if (hrc == S_OK)
2659	{
2660	/* Read until we reached the end of the stream. */
2661	for (;;)
2662	{
2663	SafeArray<BYTE> SafeArrayBuf;
2664
2665	hrc = ptrDataStream->Read(_64K, 0 /Infinite wait/, ComSafeArrayAsOutParam(SafeArrayBuf));
2666	if ( FAILED(hrc)
2667	\|\| SafeArrayBuf.size() == 0)
2668	break;
2669
2670	/* Output the data. */
2671	size_t const cbReturned = SafeArrayBuf.size();
2672	if (cbReturned)
2673	{
2674	BYTE const *pbBuf = SafeArrayBuf.raw();
2675	vrc = RTStrmWrite(pOut, pbBuf, cbReturned);
2676	if (RT_FAILURE(vrc))
2677	{
2678	rcExit = RTMsgErrorExitFailure(Disk::tr("Error writing to '%s': %Rrc"), pszOutput, vrc);
2679	break;
2680	}
2681	}
2682
2683	/** @todo Check progress. */
2684	}
2685	}
2686	else
2687	{
2688	com::GlueHandleComError(ptrMediumIO, "ConvertToStream()", hrc, __FILE__, __LINE__);
2689	rcExit = RTEXITCODE_FAILURE;
2690	}
2691
2692	/*
2693	* Close output.
2694	*/
2695	if (pOut != g_pStdOut)
2696	{
2697	vrc = RTStrmClose(pOut);
2698	if (RT_FAILURE(vrc))
2699	rcExit = RTMsgErrorExitFailure(Disk::tr("Error closing '%s': %Rrc"), pszOutput, vrc);
2700	}
2701	else
2702	RTStrmSetMode(pOut, false, -1);
2703	}
2704	}
2705	return rcExit;
2706	}
2707
2708
2709	RTEXITCODE handleMediumIO(HandlerArg *a)
2710	{
2711	/*
2712	* Parse image-option and sub-command.
2713	*/
2714	static const RTGETOPTDEF s_aOptions[] =
2715	{
2716	MEDIUMIOCOMMONOPT_DEFS(),
2717	/* sub-commands */
2718	{ "formatfat", 1000, RTGETOPT_REQ_NOTHING },
2719	{ "cat", 1001, RTGETOPT_REQ_NOTHING },
2720	{ "stream", 1002, RTGETOPT_REQ_NOTHING },
2721	};
2722	MEDIUMIOCOMMONOPT CommonOpts = { NULL, DeviceType_Null, NULL };
2723
2724	RTGETOPTSTATE GetState;
2725	int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
2726	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
2727	RTGETOPTUNION ValueUnion;
2728	while ((vrc = RTGetOpt(&GetState, &ValueUnion)) != 0)
2729	{
2730	switch (vrc)
2731	{
2732	MEDIUMIOCOMMONOPT_CASES(&CommonOpts);
2733
2734	/* Sub-commands: */
2735	case 1000:
2736	setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_FORMATFAT);
2737	return handleMediumIOFormatFat(a, GetState.iNext, &CommonOpts);
2738	case 1001:
2739	setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_CAT);
2740	return handleMediumIOCat(a, GetState.iNext, &CommonOpts);
2741	case 1002:
2742	setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_STREAM);
2743	return handleMediumIOStream(a, GetState.iNext, &CommonOpts);
2744
2745	case VINF_GETOPT_NOT_OPTION:
2746	return errorUnknownSubcommand(ValueUnion.psz);
2747
2748	default:
2749	return errorGetOpt(vrc, &ValueUnion);
2750	}
2751	}
2752	return errorNoSubcommand();
2753	}

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

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

Download in other formats: