VBoxManageDisk.cpp@ 85642

Last change on this file since 85642 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 92.2 KB

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

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

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

Download in other formats: