VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 76678 was 76553, checked in by vboxsync, 5 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 90.4 KB

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

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use