vbox-img.cpp@ 106212

Last change on this file since 106212 was 106061, checked in by vboxsync, 3 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.0 KB

Line
1	/* $Id: vbox-img.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* Standalone image manipulation tool
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/vd.h>
33	#include <VBox/err.h>
34	#include <VBox/version.h>
35	#include <iprt/initterm.h>
36	#include <iprt/asm-mem.h>
37	#include <iprt/buildconfig.h>
38	#include <iprt/fsvfs.h>
39	#include <iprt/fsisomaker.h>
40	#include <iprt/path.h>
41	#include <iprt/string.h>
42	#include <iprt/uuid.h>
43	#include <iprt/stream.h>
44	#include <iprt/message.h>
45	#include <iprt/getopt.h>
46	#include <iprt/assert.h>
47	#include <iprt/dvm.h>
48	#include <iprt/vfs.h>
49
50
51	/*********************************************************************************************************************************
52	* Global Variables *
53	*********************************************************************************************************************************/
54	static const char *g_pszProgName = "";
55
56
57
58	static void printUsage(PRTSTREAM pStrm)
59	{
60	RTStrmPrintf(pStrm,
61	"Usage: %s\n"
62	" setuuid --filename <filename>\n"
63	" [--format VDI\|VMDK\|VHD\|...]\n"
64	" [--uuid <uuid>]\n"
65	" [--parentuuid <uuid>]\n"
66	" [--zeroparentuuid]\n"
67	"\n"
68	" geometry --filename <filename>\n"
69	" [--format VDI\|VMDK\|VHD\|...]\n"
70	" [--clearchs]\n"
71	" [--cylinders <number>]\n"
72	" [--heads <number>]\n"
73	" [--sectors <number>]\n"
74	"\n"
75	" convert --srcfilename <filename>\n"
76	" --dstfilename <filename>\n"
77	" [--stdin]\|[--stdout]\n"
78	" [--srcformat VDI\|VMDK\|VHD\|RAW\|..]\n"
79	" [--dstformat VDI\|VMDK\|VHD\|RAW\|..]\n"
80	" [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
81	"\n"
82	" info --filename <filename>\n"
83	"\n"
84	" compact --filename <filename>\n"
85	" [--filesystemaware]\n"
86	"\n"
87	" createcache --filename <filename>\n"
88	" --size <cache size>\n"
89	"\n"
90	" createbase --filename <filename>\n"
91	" --size <size in bytes>\n"
92	" [--format VDI\|VMDK\|VHD] (default: VDI)\n"
93	" [--variant Standard,Fixed,Split2G,Stream,ESX]\n"
94	" [--dataalignment <alignment in bytes>]\n"
95	"\n"
96	" createfloppy --filename <filename>\n"
97	" [--size <size in bytes>]\n"
98	" [--root-dir-entries <value>]\n"
99	" [--sector-size <bytes>]\n"
100	" [--heads <value>]\n"
101	" [--sectors-per-track <count>]\n"
102	" [--media-byte <byte>]\n"
103	"\n"
104	" createiso [too-many-options]\n"
105	"\n"
106	" repair --filename <filename>\n"
107	" [--dry-run]\n"
108	" [--format VDI\|VMDK\|VHD] (default: autodetect)\n"
109	"\n"
110	" clearcomment --filename <filename>\n"
111	"\n"
112	" resize --filename <filename>\n"
113	" --size <new size>\n",
114	g_pszProgName);
115	}
116
117	static void showLogo(PRTSTREAM pStrm)
118	{
119	static bool s_fShown; /* show only once */
120
121	if (!s_fShown)
122	{
123	RTStrmPrintf(pStrm, VBOX_PRODUCT " Disk Utility " VBOX_VERSION_STRING "\n"
124	"Copyright (C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\n\n");
125	s_fShown = true;
126	}
127	}
128
129	/** command handler argument */
130	struct HandlerArg
131	{
132	int argc;
133	char **argv;
134	};
135
136	static PVDINTERFACE pVDIfs;
137
138	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
139	{
140	RT_NOREF2(pvUser, rc);
141	RT_SRC_POS_NOREF();
142	RTMsgErrorV(pszFormat, va);
143	}
144
145	static DECLCALLBACK(int) handleVDMessage(void pvUser, const char pszFormat, va_list va)
146	{
147	NOREF(pvUser);
148	RTPrintfV(pszFormat, va);
149	return VINF_SUCCESS;
150	}
151
152	/**
153	* Print a usage synopsis and the syntax error message.
154	*/
155	static int errorSyntax(const char *pszFormat, ...)
156	{
157	va_list args;
158	showLogo(g_pStdErr); // show logo even if suppressed
159	va_start(args, pszFormat);
160	RTStrmPrintf(g_pStdErr, "\nSyntax error: %N\n", pszFormat, &args);
161	va_end(args);
162	printUsage(g_pStdErr);
163	return 1;
164	}
165
166	static int errorRuntime(const char *pszFormat, ...)
167	{
168	va_list args;
169
170	va_start(args, pszFormat);
171	RTMsgErrorV(pszFormat, args);
172	va_end(args);
173	return 1;
174	}
175
176	static int parseDiskVariant(const char psz, unsigned puImageFlags)
177	{
178	int rc = VINF_SUCCESS;
179	unsigned uImageFlags = *puImageFlags;
180
181	while (psz && *psz && RT_SUCCESS(rc))
182	{
183	size_t len;
184	const char *pszComma = strchr(psz, ',');
185	if (pszComma)
186	len = pszComma - psz;
187	else
188	len = strlen(psz);
189	if (len > 0)
190	{
191	/*
192	* Parsing is intentionally inconsistent: "standard" resets the
193	* variant, whereas the other flags are cumulative.
194	*/
195	if (!RTStrNICmp(psz, "standard", len))
196	uImageFlags = VD_IMAGE_FLAGS_NONE;
197	else if ( !RTStrNICmp(psz, "fixed", len)
198	\|\| !RTStrNICmp(psz, "static", len))
199	uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
200	else if (!RTStrNICmp(psz, "Diff", len))
201	uImageFlags \|= VD_IMAGE_FLAGS_DIFF;
202	else if (!RTStrNICmp(psz, "split2g", len))
203	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
204	else if ( !RTStrNICmp(psz, "stream", len)
205	\|\| !RTStrNICmp(psz, "streamoptimized", len))
206	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED;
207	else if (!RTStrNICmp(psz, "esx", len))
208	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_ESX;
209	else
210	rc = VERR_PARSE_ERROR;
211	}
212	if (pszComma)
213	psz += len + 1;
214	else
215	psz += len;
216	}
217
218	if (RT_SUCCESS(rc))
219	*puImageFlags = uImageFlags;
220	return rc;
221	}
222
223
224	static int handleSetUUID(HandlerArg *a)
225	{
226	const char *pszFilename = NULL;
227	char *pszFormat = NULL;
228	VDTYPE enmType = VDTYPE_INVALID;
229	RTUUID imageUuid;
230	RTUUID parentUuid;
231	bool fSetImageUuid = false;
232	bool fSetParentUuid = false;
233	RTUuidClear(&imageUuid);
234	RTUuidClear(&parentUuid);
235	int rc;
236
237	/* Parse the command line. */
238	static const RTGETOPTDEF s_aOptions[] =
239	{
240	{ "--filename", 'f', RTGETOPT_REQ_STRING },
241	{ "--format", 'o', RTGETOPT_REQ_STRING },
242	{ "--uuid", 'u', RTGETOPT_REQ_UUID },
243	{ "--parentuuid", 'p', RTGETOPT_REQ_UUID },
244	{ "--zeroparentuuid", 'P', RTGETOPT_REQ_NOTHING }
245	};
246	int ch;
247	RTGETOPTUNION ValueUnion;
248	RTGETOPTSTATE GetState;
249	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
250	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
251	{
252	switch (ch)
253	{
254	case 'f': // --filename
255	pszFilename = ValueUnion.psz;
256	break;
257	case 'o': // --format
258	pszFormat = RTStrDup(ValueUnion.psz);
259	break;
260	case 'u': // --uuid
261	imageUuid = ValueUnion.Uuid;
262	fSetImageUuid = true;
263	break;
264	case 'p': // --parentuuid
265	parentUuid = ValueUnion.Uuid;
266	fSetParentUuid = true;
267	break;
268	case 'P': // --zeroparentuuid
269	RTUuidClear(&parentUuid);
270	fSetParentUuid = true;
271	break;
272
273	default:
274	ch = RTGetOptPrintError(ch, &ValueUnion);
275	printUsage(g_pStdErr);
276	return ch;
277	}
278	}
279
280	/* Check for mandatory parameters. */
281	if (!pszFilename)
282	return errorSyntax("Mandatory --filename option missing\n");
283
284	/* Check for consistency of optional parameters. */
285	if (fSetImageUuid && RTUuidIsNull(&imageUuid))
286	return errorSyntax("Invalid parameter to --uuid option\n");
287
288	/* Autodetect image format. */
289	if (!pszFormat)
290	{
291	/* Don't pass error interface, as that would triggers error messages
292	* because some backends fail to open the image. */
293	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
294	if (RT_FAILURE(rc))
295	return errorRuntime("Format autodetect failed: %Rrc\n", rc);
296	}
297
298	PVDISK pVD = NULL;
299	rc = VDCreate(pVDIfs, enmType, &pVD);
300	if (RT_FAILURE(rc))
301	return errorRuntime("Cannot create the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
302
303	/* Open in info mode to be able to open diff images without their parent. */
304	rc = VDOpen(pVD, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO, NULL);
305	if (RT_FAILURE(rc))
306	return errorRuntime("Cannot open the virtual disk image \"%s\": %Rrf (%Rrc)\n",
307	pszFilename, rc, rc);
308
309	RTUUID oldImageUuid;
310	rc = VDGetUuid(pVD, VD_LAST_IMAGE, &oldImageUuid);
311	if (RT_FAILURE(rc))
312	return errorRuntime("Cannot get UUID of virtual disk image \"%s\": %Rrc\n",
313	pszFilename, rc);
314
315	RTPrintf("Old image UUID: %RTuuid\n", &oldImageUuid);
316
317	RTUUID oldParentUuid;
318	rc = VDGetParentUuid(pVD, VD_LAST_IMAGE, &oldParentUuid);
319	if (RT_FAILURE(rc))
320	return errorRuntime("Cannot get parent UUID of virtual disk image \"%s\": %Rrc\n",
321	pszFilename, rc);
322
323	RTPrintf("Old parent UUID: %RTuuid\n", &oldParentUuid);
324
325	if (fSetImageUuid)
326	{
327	RTPrintf("New image UUID: %RTuuid\n", &imageUuid);
328	rc = VDSetUuid(pVD, VD_LAST_IMAGE, &imageUuid);
329	if (RT_FAILURE(rc))
330	return errorRuntime("Cannot set UUID of virtual disk image \"%s\": %Rrf (%Rrc)\n",
331	pszFilename, rc, rc);
332	}
333
334	if (fSetParentUuid)
335	{
336	RTPrintf("New parent UUID: %RTuuid\n", &parentUuid);
337	rc = VDSetParentUuid(pVD, VD_LAST_IMAGE, &parentUuid);
338	if (RT_FAILURE(rc))
339	return errorRuntime("Cannot set parent UUID of virtual disk image \"%s\": %Rrf (%Rrc)\n",
340	pszFilename, rc, rc);
341	}
342
343	VDDestroy(pVD);
344
345	if (pszFormat)
346	{
347	RTStrFree(pszFormat);
348	pszFormat = NULL;
349	}
350
351	return 0;
352	}
353
354
355	static int handleGeometry(HandlerArg *a)
356	{
357	const char *pszFilename = NULL;
358	char *pszFormat = NULL;
359	VDTYPE enmType = VDTYPE_INVALID;
360	uint16_t cCylinders = 0;
361	uint8_t cHeads = 0;
362	uint8_t cSectors = 0;
363	bool fCylinders = false;
364	bool fHeads = false;
365	bool fSectors = false;
366	int rc;
367
368	/* Parse the command line. */
369	static const RTGETOPTDEF s_aOptions[] =
370	{
371	{ "--filename", 'f', RTGETOPT_REQ_STRING },
372	{ "--format", 'o', RTGETOPT_REQ_STRING },
373	{ "--clearchs", 'C', RTGETOPT_REQ_NOTHING },
374	{ "--cylinders", 'c', RTGETOPT_REQ_UINT16 },
375	{ "--heads", 'e', RTGETOPT_REQ_UINT8 },
376	{ "--sectors", 's', RTGETOPT_REQ_UINT8 }
377	};
378	int ch;
379	RTGETOPTUNION ValueUnion;
380	RTGETOPTSTATE GetState;
381	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
382	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
383	{
384	switch (ch)
385	{
386	case 'f': // --filename
387	pszFilename = ValueUnion.psz;
388	break;
389	case 'o': // --format
390	pszFormat = RTStrDup(ValueUnion.psz);
391	break;
392	case 'C': // --clearchs
393	cCylinders = 0;
394	cHeads = 0;
395	cSectors = 0;
396	fCylinders = true;
397	fHeads = true;
398	fSectors = true;
399	break;
400	case 'c': // --cylinders
401	cCylinders = ValueUnion.u16;
402	fCylinders = true;
403	break;
404	case 'e': // --heads
405	cHeads = ValueUnion.u8;
406	fHeads = true;
407	break;
408	case 's': // --sectors
409	cSectors = ValueUnion.u8;
410	fSectors = true;
411	break;
412
413	default:
414	ch = RTGetOptPrintError(ch, &ValueUnion);
415	printUsage(g_pStdErr);
416	return ch;
417	}
418	}
419
420	/* Check for mandatory parameters. */
421	if (!pszFilename)
422	return errorSyntax("Mandatory --filename option missing\n");
423
424	/* Autodetect image format. */
425	if (!pszFormat)
426	{
427	/* Don't pass error interface, as that would triggers error messages
428	* because some backends fail to open the image. */
429	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
430	if (RT_FAILURE(rc))
431	return errorRuntime("Format autodetect failed: %Rrc\n", rc);
432	}
433
434	PVDISK pVD = NULL;
435	rc = VDCreate(pVDIfs, enmType, &pVD);
436	if (RT_FAILURE(rc))
437	return errorRuntime("Cannot create the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
438
439	/* Open in info mode to be able to open diff images without their parent. */
440	rc = VDOpen(pVD, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO, NULL);
441	if (RT_FAILURE(rc))
442	return errorRuntime("Cannot open the virtual disk image \"%s\": %Rrf (%Rrc)\n",
443	pszFilename, rc, rc);
444
445	VDGEOMETRY oldLCHSGeometry;
446	rc = VDGetLCHSGeometry(pVD, VD_LAST_IMAGE, &oldLCHSGeometry);
447	if (rc == VERR_VD_GEOMETRY_NOT_SET)
448	{
449	memset(&oldLCHSGeometry, 0, sizeof(oldLCHSGeometry));
450	rc = VINF_SUCCESS;
451	}
452	if (RT_FAILURE(rc))
453	return errorRuntime("Cannot get LCHS geometry of virtual disk image \"%s\": %Rrc\n",
454	pszFilename, rc);
455
456	VDGEOMETRY newLCHSGeometry = oldLCHSGeometry;
457	if (fCylinders)
458	newLCHSGeometry.cCylinders = cCylinders;
459	if (fHeads)
460	newLCHSGeometry.cHeads = cHeads;
461	if (fSectors)
462	newLCHSGeometry.cSectors = cSectors;
463
464	if (fCylinders \|\| fHeads \|\| fSectors)
465	{
466	RTPrintf("Old image LCHS: %u/%u/%u\n", oldLCHSGeometry.cCylinders, oldLCHSGeometry.cHeads, oldLCHSGeometry.cSectors);
467	RTPrintf("New image LCHS: %u/%u/%u\n", newLCHSGeometry.cCylinders, newLCHSGeometry.cHeads, newLCHSGeometry.cSectors);
468
469	rc = VDSetLCHSGeometry(pVD, VD_LAST_IMAGE, &newLCHSGeometry);
470	if (RT_FAILURE(rc))
471	return errorRuntime("Cannot set LCHS geometry of virtual disk image \"%s\": %Rrf (%Rrc)\n",
472	pszFilename, rc, rc);
473	}
474	else
475	RTPrintf("Current image LCHS: %u/%u/%u\n", oldLCHSGeometry.cCylinders, oldLCHSGeometry.cHeads, oldLCHSGeometry.cSectors);
476
477
478	VDDestroy(pVD);
479
480	if (pszFormat)
481	{
482	RTStrFree(pszFormat);
483	pszFormat = NULL;
484	}
485
486	return 0;
487	}
488
489
490	typedef struct FILEIOSTATE
491	{
492	RTFILE file;
493	/** Size of file. */
494	uint64_t cb;
495	/** Offset in the file. */
496	uint64_t off;
497	/** Offset where the buffer contents start. UINT64_MAX=buffer invalid. */
498	uint64_t offBuffer;
499	/** Size of valid data in the buffer. */
500	uint32_t cbBuffer;
501	/** Buffer for efficient I/O */
502	uint8_t abBuffer[16 *_1M];
503	} FILEIOSTATE, *PFILEIOSTATE;
504
505	static DECLCALLBACK(int) convInOpen(void pvUser, const char pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
506	void **ppStorage)
507	{
508	RT_NOREF2(pvUser, pszLocation);
509
510	/* Validate input. */
511	AssertPtrReturn(ppStorage, VERR_INVALID_POINTER);
512	AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
513	AssertReturn((fOpen & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ, VERR_INVALID_PARAMETER);
514	RTFILE file;
515	int rc = RTFileFromNative(&file, RTFILE_NATIVE_STDIN);
516	if (RT_FAILURE(rc))
517	return rc;
518
519	/* No need to clear the buffer, the data will be read from disk. */
520	PFILEIOSTATE pFS = (PFILEIOSTATE)RTMemAlloc(sizeof(FILEIOSTATE));
521	if (!pFS)
522	return VERR_NO_MEMORY;
523
524	pFS->file = file;
525	pFS->cb = 0;
526	pFS->off = 0;
527	pFS->offBuffer = UINT64_MAX;
528	pFS->cbBuffer = 0;
529
530	*ppStorage = pFS;
531	return VINF_SUCCESS;
532	}
533
534	static DECLCALLBACK(int) convInClose(void pvUser, void pStorage)
535	{
536	NOREF(pvUser);
537	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
538	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
539
540	RTMemFree(pFS);
541
542	return VINF_SUCCESS;
543	}
544
545	static DECLCALLBACK(int) convInDelete(void pvUser, const char pcszFilename)
546	{
547	NOREF(pvUser);
548	NOREF(pcszFilename);
549	AssertFailedReturn(VERR_NOT_SUPPORTED);
550	}
551
552	static DECLCALLBACK(int) convInMove(void pvUser, const char pcszSrc, const char *pcszDst, unsigned fMove)
553	{
554	NOREF(pvUser);
555	NOREF(pcszSrc);
556	NOREF(pcszDst);
557	NOREF(fMove);
558	AssertFailedReturn(VERR_NOT_SUPPORTED);
559	}
560
561	static DECLCALLBACK(int) convInGetFreeSpace(void pvUser, const char pcszFilename, int64_t *pcbFreeSpace)
562	{
563	NOREF(pvUser);
564	NOREF(pcszFilename);
565	AssertPtrReturn(pcbFreeSpace, VERR_INVALID_POINTER);
566	*pcbFreeSpace = 0;
567	return VINF_SUCCESS;
568	}
569
570	static DECLCALLBACK(int) convInGetModificationTime(void pvUser, const char pcszFilename, PRTTIMESPEC pModificationTime)
571	{
572	NOREF(pvUser);
573	NOREF(pcszFilename);
574	AssertPtrReturn(pModificationTime, VERR_INVALID_POINTER);
575	AssertFailedReturn(VERR_NOT_SUPPORTED);
576	}
577
578	static DECLCALLBACK(int) convInGetSize(void pvUser, void pStorage, uint64_t *pcbSize)
579	{
580	NOREF(pvUser);
581	NOREF(pStorage);
582	AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
583	AssertFailedReturn(VERR_NOT_SUPPORTED);
584	}
585
586	static DECLCALLBACK(int) convInSetSize(void pvUser, void pStorage, uint64_t cbSize)
587	{
588	NOREF(pvUser);
589	NOREF(pStorage);
590	NOREF(cbSize);
591	AssertFailedReturn(VERR_NOT_SUPPORTED);
592	}
593
594	static DECLCALLBACK(int) convInRead(void pvUser, void pStorage, uint64_t uOffset,
595	void pvBuffer, size_t cbBuffer, size_t pcbRead)
596	{
597	NOREF(pvUser);
598	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
599	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
600	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
601	AssertReturn(uOffset >= pFS->off, VERR_INVALID_PARAMETER);
602	int rc;
603
604	/* Fill buffer if it is empty. */
605	if (pFS->offBuffer == UINT64_MAX)
606	{
607	/* Repeat reading until buffer is full or EOF. */
608	size_t cbRead;
609	size_t cbSumRead = 0;
610	uint8_t pbTmp = (uint8_t )&pFS->abBuffer[0];
611	size_t cbTmp = sizeof(pFS->abBuffer);
612	do
613	{
614	rc = RTFileRead(pFS->file, pbTmp, cbTmp, &cbRead);
615	if (RT_FAILURE(rc))
616	return rc;
617	pbTmp += cbRead;
618	cbTmp -= cbRead;
619	cbSumRead += cbRead;
620	} while (cbTmp && cbRead);
621
622	pFS->offBuffer = 0;
623	pFS->cbBuffer = (uint32_t)cbSumRead;
624	if (!cbSumRead && !pcbRead) /* Caller can't handle partial reads. */
625	return VERR_EOF;
626	}
627
628	/* Read several blocks and assemble the result if necessary */
629	size_t cbTotalRead = 0;
630	do
631	{
632	/* Skip over areas no one wants to read. */
633	while (uOffset > pFS->offBuffer + pFS->cbBuffer - 1)
634	{
635	if (pFS->cbBuffer < sizeof(pFS->abBuffer))
636	{
637	if (pcbRead)
638	*pcbRead = cbTotalRead;
639	return VERR_EOF;
640	}
641
642	/* Repeat reading until buffer is full or EOF. */
643	size_t cbRead;
644	size_t cbSumRead = 0;
645	uint8_t pbTmp = (uint8_t )&pFS->abBuffer[0];
646	size_t cbTmp = sizeof(pFS->abBuffer);
647	do
648	{
649	rc = RTFileRead(pFS->file, pbTmp, cbTmp, &cbRead);
650	if (RT_FAILURE(rc))
651	return rc;
652	pbTmp += cbRead;
653	cbTmp -= cbRead;
654	cbSumRead += cbRead;
655	} while (cbTmp && cbRead);
656
657	pFS->offBuffer += pFS->cbBuffer;
658	pFS->cbBuffer = (uint32_t)cbSumRead;
659	}
660
661	uint32_t cbThisRead = (uint32_t)RT_MIN(cbBuffer,
662	pFS->cbBuffer - uOffset % sizeof(pFS->abBuffer));
663	memcpy(pvBuffer, &pFS->abBuffer[uOffset % sizeof(pFS->abBuffer)],
664	cbThisRead);
665	uOffset += cbThisRead;
666	pvBuffer = (uint8_t *)pvBuffer + cbThisRead;
667	cbBuffer -= cbThisRead;
668	cbTotalRead += cbThisRead;
669	if (!cbTotalRead && !pcbRead) /* Caller can't handle partial reads. */
670	return VERR_EOF;
671	} while (cbBuffer > 0);
672
673	if (pcbRead)
674	*pcbRead = cbTotalRead;
675
676	pFS->off = uOffset;
677
678	return VINF_SUCCESS;
679	}
680
681	static DECLCALLBACK(int) convInWrite(void pvUser, void pStorage, uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
682	size_t *pcbWritten)
683	{
684	NOREF(pvUser);
685	NOREF(pStorage);
686	NOREF(uOffset);
687	NOREF(cbBuffer);
688	NOREF(pcbWritten);
689	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
690	AssertFailedReturn(VERR_NOT_SUPPORTED);
691	}
692
693	static DECLCALLBACK(int) convInFlush(void pvUser, void pStorage)
694	{
695	NOREF(pvUser);
696	NOREF(pStorage);
697	return VINF_SUCCESS;
698	}
699
700	static DECLCALLBACK(int) convStdOutOpen(void pvUser, const char pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
701	void **ppStorage)
702	{
703	RT_NOREF2(pvUser, pszLocation);
704
705	/* Validate input. */
706	AssertPtrReturn(ppStorage, VERR_INVALID_POINTER);
707	AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
708	AssertReturn((fOpen & RTFILE_O_ACCESS_MASK) == RTFILE_O_WRITE, VERR_INVALID_PARAMETER);
709	RTFILE file;
710	int rc = RTFileFromNative(&file, RTFILE_NATIVE_STDOUT);
711	if (RT_FAILURE(rc))
712	return rc;
713
714	/* Must clear buffer, so that skipped over data is initialized properly. */
715	PFILEIOSTATE pFS = (PFILEIOSTATE)RTMemAllocZ(sizeof(FILEIOSTATE));
716	if (!pFS)
717	return VERR_NO_MEMORY;
718
719	pFS->file = file;
720	pFS->cb = 0;
721	pFS->off = 0;
722	pFS->offBuffer = 0;
723	pFS->cbBuffer = sizeof(FILEIOSTATE);
724
725	*ppStorage = pFS;
726	return VINF_SUCCESS;
727	}
728
729	static DECLCALLBACK(int) convStdOutClose(void pvUser, void pStorage)
730	{
731	NOREF(pvUser);
732	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
733	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
734	int rc = VINF_SUCCESS;
735
736	/* Flush any remaining buffer contents. */
737	if (pFS->cbBuffer)
738	rc = RTFileWrite(pFS->file, &pFS->abBuffer[0], pFS->cbBuffer, NULL);
739	if ( RT_SUCCESS(rc)
740	&& pFS->cb > pFS->off)
741	{
742	/* Write zeros if the set file size is not met. */
743	uint64_t cbLeft = pFS->cb - pFS->off;
744	RT_ZERO(pFS->abBuffer);
745
746	while (cbLeft)
747	{
748	size_t cbThisWrite = RT_MIN(cbLeft, sizeof(pFS->abBuffer));
749	rc = RTFileWrite(pFS->file, &pFS->abBuffer[0],
750	cbThisWrite, NULL);
751	cbLeft -= cbThisWrite;
752	}
753	}
754
755	RTMemFree(pFS);
756
757	return rc;
758	}
759
760	static DECLCALLBACK(int) convStdOutDelete(void pvUser, const char pcszFilename)
761	{
762	NOREF(pvUser);
763	NOREF(pcszFilename);
764	AssertFailedReturn(VERR_NOT_SUPPORTED);
765	}
766
767	static DECLCALLBACK(int) convStdOutMove(void pvUser, const char pcszSrc, const char *pcszDst, unsigned fMove)
768	{
769	NOREF(pvUser);
770	NOREF(pcszSrc);
771	NOREF(pcszDst);
772	NOREF(fMove);
773	AssertFailedReturn(VERR_NOT_SUPPORTED);
774	}
775
776	static DECLCALLBACK(int) convStdOutGetFreeSpace(void pvUser, const char pcszFilename, int64_t *pcbFreeSpace)
777	{
778	NOREF(pvUser);
779	NOREF(pcszFilename);
780	AssertPtrReturn(pcbFreeSpace, VERR_INVALID_POINTER);
781	*pcbFreeSpace = INT64_MAX;
782	return VINF_SUCCESS;
783	}
784
785	static DECLCALLBACK(int) convStdOutGetModificationTime(void pvUser, const char pcszFilename, PRTTIMESPEC pModificationTime)
786	{
787	NOREF(pvUser);
788	NOREF(pcszFilename);
789	AssertPtrReturn(pModificationTime, VERR_INVALID_POINTER);
790	AssertFailedReturn(VERR_NOT_SUPPORTED);
791	}
792
793	static DECLCALLBACK(int) convStdOutGetSize(void pvUser, void pStorage, uint64_t *pcbSize)
794	{
795	NOREF(pvUser);
796	NOREF(pStorage);
797	AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
798	AssertFailedReturn(VERR_NOT_SUPPORTED);
799	}
800
801	static DECLCALLBACK(int) convStdOutSetSize(void pvUser, void pStorage, uint64_t cbSize)
802	{
803	RT_NOREF2(pvUser, cbSize);
804	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
805	AssertFailedReturn(VERR_NOT_SUPPORTED);
806	}
807
808	static DECLCALLBACK(int) convStdOutRead(void pvUser, void pStorage, uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
809	size_t *pcbRead)
810	{
811	NOREF(pvUser);
812	NOREF(pStorage);
813	NOREF(uOffset);
814	NOREF(cbBuffer);
815	NOREF(pcbRead);
816	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
817	AssertFailedReturn(VERR_NOT_SUPPORTED);
818	}
819
820	static DECLCALLBACK(int) convStdOutWrite(void pvUser, void pStorage, uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
821	size_t *pcbWritten)
822	{
823	NOREF(pvUser);
824	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
825	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
826	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
827	AssertReturn(uOffset >= pFS->off, VERR_INVALID_PARAMETER);
828
829	/* Write the data to the buffer, flushing as required. */
830	size_t cbTotalWritten = 0;
831	do
832	{
833	/* Flush the buffer if we need a new one. */
834	while (uOffset > pFS->offBuffer + sizeof(pFS->abBuffer) - 1)
835	{
836	int rc = RTFileWrite(pFS->file, &pFS->abBuffer[0],
837	sizeof(pFS->abBuffer), NULL);
838	if (RT_FAILURE(rc))
839	return rc;
840
841	RT_ZERO(pFS->abBuffer);
842	pFS->offBuffer += sizeof(pFS->abBuffer);
843	pFS->cbBuffer = 0;
844	}
845
846	uint32_t cbThisWrite = (uint32_t)RT_MIN(cbBuffer,
847	sizeof(pFS->abBuffer) - uOffset % sizeof(pFS->abBuffer));
848	memcpy(&pFS->abBuffer[uOffset % sizeof(pFS->abBuffer)], pvBuffer,
849	cbThisWrite);
850	uOffset += cbThisWrite;
851	pvBuffer = (uint8_t *)pvBuffer + cbThisWrite;
852	cbBuffer -= cbThisWrite;
853	cbTotalWritten += cbThisWrite;
854	} while (cbBuffer > 0);
855
856	if (pcbWritten)
857	*pcbWritten = cbTotalWritten;
858
859	pFS->cbBuffer = uOffset % sizeof(pFS->abBuffer);
860	if (!pFS->cbBuffer)
861	pFS->cbBuffer = sizeof(pFS->abBuffer);
862	pFS->off = uOffset;
863
864	return VINF_SUCCESS;
865	}
866
867	static DECLCALLBACK(int) convStdOutFlush(void pvUser, void pStorage)
868	{
869	NOREF(pvUser);
870	NOREF(pStorage);
871	return VINF_SUCCESS;
872	}
873
874	static DECLCALLBACK(int) convFileOutOpen(void pvUser, const char pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
875	void **ppStorage)
876	{
877	RT_NOREF1(pvUser);
878
879	/* Validate input. */
880	AssertPtrReturn(ppStorage, VERR_INVALID_POINTER);
881	AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
882	AssertReturn((fOpen & RTFILE_O_ACCESS_MASK) == RTFILE_O_WRITE, VERR_INVALID_PARAMETER);
883	RTFILE file;
884	int rc = RTFileOpen(&file, pszLocation, fOpen);
885	if (RT_FAILURE(rc))
886	return rc;
887
888	/* Must clear buffer, so that skipped over data is initialized properly. */
889	PFILEIOSTATE pFS = (PFILEIOSTATE)RTMemAllocZ(sizeof(FILEIOSTATE));
890	if (!pFS)
891	return VERR_NO_MEMORY;
892
893	pFS->file = file;
894	pFS->cb = 0;
895	pFS->off = 0;
896	pFS->offBuffer = 0;
897	pFS->cbBuffer = sizeof(FILEIOSTATE);
898
899	*ppStorage = pFS;
900	return VINF_SUCCESS;
901	}
902
903	static DECLCALLBACK(int) convFileOutClose(void pvUser, void pStorage)
904	{
905	NOREF(pvUser);
906	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
907	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
908	int rc = VINF_SUCCESS;
909
910	/* Flush any remaining buffer contents. */
911	if (pFS->cbBuffer)
912	rc = RTFileWriteAt(pFS->file, pFS->offBuffer, &pFS->abBuffer[0], pFS->cbBuffer, NULL);
913	RTFileClose(pFS->file);
914
915	RTMemFree(pFS);
916
917	return rc;
918	}
919
920	static DECLCALLBACK(int) convFileOutDelete(void pvUser, const char pcszFilename)
921	{
922	NOREF(pvUser);
923	NOREF(pcszFilename);
924	AssertFailedReturn(VERR_NOT_SUPPORTED);
925	}
926
927	static DECLCALLBACK(int) convFileOutMove(void pvUser, const char pcszSrc, const char *pcszDst, unsigned fMove)
928	{
929	NOREF(pvUser);
930	NOREF(pcszSrc);
931	NOREF(pcszDst);
932	NOREF(fMove);
933	AssertFailedReturn(VERR_NOT_SUPPORTED);
934	}
935
936	static DECLCALLBACK(int) convFileOutGetFreeSpace(void pvUser, const char pcszFilename, int64_t *pcbFreeSpace)
937	{
938	NOREF(pvUser);
939	NOREF(pcszFilename);
940	AssertPtrReturn(pcbFreeSpace, VERR_INVALID_POINTER);
941	*pcbFreeSpace = INT64_MAX;
942	return VINF_SUCCESS;
943	}
944
945	static DECLCALLBACK(int) convFileOutGetModificationTime(void pvUser, const char pcszFilename, PRTTIMESPEC pModificationTime)
946	{
947	NOREF(pvUser);
948	NOREF(pcszFilename);
949	AssertPtrReturn(pModificationTime, VERR_INVALID_POINTER);
950	AssertFailedReturn(VERR_NOT_SUPPORTED);
951	}
952
953	static DECLCALLBACK(int) convFileOutGetSize(void pvUser, void pStorage, uint64_t *pcbSize)
954	{
955	NOREF(pvUser);
956	NOREF(pStorage);
957	AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
958	AssertFailedReturn(VERR_NOT_SUPPORTED);
959	}
960
961	static DECLCALLBACK(int) convFileOutSetSize(void pvUser, void pStorage, uint64_t cbSize)
962	{
963	NOREF(pvUser);
964	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
965	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
966
967	int rc = RTFileSetSize(pFS->file, cbSize);
968	if (RT_SUCCESS(rc))
969	pFS->cb = cbSize;
970	return rc;
971	}
972
973	static DECLCALLBACK(int) convFileOutRead(void pvUser, void pStorage, uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
974	size_t *pcbRead)
975	{
976	NOREF(pvUser);
977	NOREF(pStorage);
978	NOREF(uOffset);
979	NOREF(cbBuffer);
980	NOREF(pcbRead);
981	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
982	AssertFailedReturn(VERR_NOT_SUPPORTED);
983	}
984
985	static DECLCALLBACK(int) convFileOutWrite(void pvUser, void pStorage, uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
986	size_t *pcbWritten)
987	{
988	NOREF(pvUser);
989	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
990	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
991	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
992	AssertReturn(uOffset >= pFS->off, VERR_INVALID_PARAMETER);
993
994	/* Write the data to the buffer, flushing as required. */
995	size_t cbTotalWritten = 0;
996	do
997	{
998	/* Flush the buffer if we need a new one. */
999	while (uOffset > pFS->offBuffer + sizeof(pFS->abBuffer) - 1)
1000	{
1001	if (!ASMMemIsZero(pFS->abBuffer, sizeof(pFS->abBuffer)))
1002	{
1003	int rc = RTFileWriteAt(pFS->file, pFS->offBuffer,
1004	&pFS->abBuffer[0],
1005	sizeof(pFS->abBuffer), NULL);
1006	if (RT_FAILURE(rc))
1007	return rc;
1008	}
1009	RT_ZERO(pFS->abBuffer);
1010	pFS->offBuffer += sizeof(pFS->abBuffer);
1011	pFS->cbBuffer = 0;
1012	}
1013
1014	uint32_t cbThisWrite = (uint32_t)RT_MIN(cbBuffer,
1015	sizeof(pFS->abBuffer) - uOffset % sizeof(pFS->abBuffer));
1016	memcpy(&pFS->abBuffer[uOffset % sizeof(pFS->abBuffer)], pvBuffer,
1017	cbThisWrite);
1018	uOffset += cbThisWrite;
1019	pvBuffer = (uint8_t *)pvBuffer + cbThisWrite;
1020	cbBuffer -= cbThisWrite;
1021	cbTotalWritten += cbThisWrite;
1022	} while (cbBuffer > 0);
1023
1024	if (pcbWritten)
1025	*pcbWritten = cbTotalWritten;
1026
1027	pFS->cbBuffer = uOffset % sizeof(pFS->abBuffer);
1028	if (!pFS->cbBuffer)
1029	pFS->cbBuffer = sizeof(pFS->abBuffer);
1030	pFS->off = uOffset;
1031
1032	return VINF_SUCCESS;
1033	}
1034
1035	static DECLCALLBACK(int) convFileOutFlush(void pvUser, void pStorage)
1036	{
1037	NOREF(pvUser);
1038	NOREF(pStorage);
1039	return VINF_SUCCESS;
1040	}
1041
1042	static int handleConvert(HandlerArg *a)
1043	{
1044	const char *pszSrcFilename = NULL;
1045	const char *pszDstFilename = NULL;
1046	bool fStdIn = false;
1047	bool fStdOut = false;
1048	bool fCreateSparse = false;
1049	const char *pszSrcFormat = NULL;
1050	VDTYPE enmSrcType = VDTYPE_HDD;
1051	const char *pszDstFormat = NULL;
1052	const char *pszVariant = NULL;
1053	PVDISK pSrcDisk = NULL;
1054	PVDISK pDstDisk = NULL;
1055	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1056	PVDINTERFACE pIfsImageInput = NULL;
1057	PVDINTERFACE pIfsImageOutput = NULL;
1058	VDINTERFACEIO IfsInputIO;
1059	VDINTERFACEIO IfsOutputIO;
1060	int rc = VINF_SUCCESS;
1061
1062	/* Parse the command line. */
1063	static const RTGETOPTDEF s_aOptions[] =
1064	{
1065	{ "--srcfilename", 'i', RTGETOPT_REQ_STRING },
1066	{ "--dstfilename", 'o', RTGETOPT_REQ_STRING },
1067	{ "--stdin", 'p', RTGETOPT_REQ_NOTHING },
1068	{ "--stdout", 'P', RTGETOPT_REQ_NOTHING },
1069	{ "--srcformat", 's', RTGETOPT_REQ_STRING },
1070	{ "--dstformat", 'd', RTGETOPT_REQ_STRING },
1071	{ "--variant", 'v', RTGETOPT_REQ_STRING },
1072	{ "--create-sparse", 'c', RTGETOPT_REQ_NOTHING }
1073	};
1074	int ch;
1075	RTGETOPTUNION ValueUnion;
1076	RTGETOPTSTATE GetState;
1077	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1078	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1079	{
1080	switch (ch)
1081	{
1082	case 'i': // --srcfilename
1083	pszSrcFilename = ValueUnion.psz;
1084	break;
1085	case 'o': // --dstfilename
1086	pszDstFilename = ValueUnion.psz;
1087	break;
1088	case 'p': // --stdin
1089	fStdIn = true;
1090	break;
1091	case 'P': // --stdout
1092	fStdOut = true;
1093	break;
1094	case 's': // --srcformat
1095	pszSrcFormat = ValueUnion.psz;
1096	break;
1097	case 'd': // --dstformat
1098	pszDstFormat = ValueUnion.psz;
1099	break;
1100	case 'v': // --variant
1101	pszVariant = ValueUnion.psz;
1102	break;
1103	case 'c': // --create-sparse
1104	fCreateSparse = true;
1105	break;
1106
1107	default:
1108	ch = RTGetOptPrintError(ch, &ValueUnion);
1109	printUsage(g_pStdErr);
1110	return ch;
1111	}
1112	}
1113
1114	/* Check for mandatory parameters and handle dummies/defaults. */
1115	if (fStdIn && !pszSrcFormat)
1116	return errorSyntax("Mandatory --srcformat option missing\n");
1117	if (!pszDstFormat)
1118	pszDstFormat = "VDI";
1119	if (fStdIn && !pszSrcFilename)
1120	{
1121	/* Complete dummy, will be just passed to various calls to fulfill
1122	* the "must be non-NULL" requirement, and is completely ignored
1123	* otherwise. It shown in the stderr message below. */
1124	pszSrcFilename = "stdin";
1125	}
1126	if (fStdOut && !pszDstFilename)
1127	{
1128	/* Will be stored in the destination image if it is a streamOptimized
1129	* VMDK, but it isn't really relevant - use it for "branding". */
1130	if (!RTStrICmp(pszDstFormat, "VMDK"))
1131	pszDstFilename = "VirtualBoxStream.vmdk";
1132	else
1133	pszDstFilename = "stdout";
1134	}
1135	if (!pszSrcFilename)
1136	return errorSyntax("Mandatory --srcfilename option missing\n");
1137	if (!pszDstFilename)
1138	return errorSyntax("Mandatory --dstfilename option missing\n");
1139
1140	if (fStdIn)
1141	{
1142	IfsInputIO.pfnOpen = convInOpen;
1143	IfsInputIO.pfnClose = convInClose;
1144	IfsInputIO.pfnDelete = convInDelete;
1145	IfsInputIO.pfnMove = convInMove;
1146	IfsInputIO.pfnGetFreeSpace = convInGetFreeSpace;
1147	IfsInputIO.pfnGetModificationTime = convInGetModificationTime;
1148	IfsInputIO.pfnGetSize = convInGetSize;
1149	IfsInputIO.pfnSetSize = convInSetSize;
1150	IfsInputIO.pfnReadSync = convInRead;
1151	IfsInputIO.pfnWriteSync = convInWrite;
1152	IfsInputIO.pfnFlushSync = convInFlush;
1153	VDInterfaceAdd(&IfsInputIO.Core, "stdin", VDINTERFACETYPE_IO,
1154	NULL, sizeof(VDINTERFACEIO), &pIfsImageInput);
1155	}
1156	if (fStdOut)
1157	{
1158	IfsOutputIO.pfnOpen = convStdOutOpen;
1159	IfsOutputIO.pfnClose = convStdOutClose;
1160	IfsOutputIO.pfnDelete = convStdOutDelete;
1161	IfsOutputIO.pfnMove = convStdOutMove;
1162	IfsOutputIO.pfnGetFreeSpace = convStdOutGetFreeSpace;
1163	IfsOutputIO.pfnGetModificationTime = convStdOutGetModificationTime;
1164	IfsOutputIO.pfnGetSize = convStdOutGetSize;
1165	IfsOutputIO.pfnSetSize = convStdOutSetSize;
1166	IfsOutputIO.pfnReadSync = convStdOutRead;
1167	IfsOutputIO.pfnWriteSync = convStdOutWrite;
1168	IfsOutputIO.pfnFlushSync = convStdOutFlush;
1169	VDInterfaceAdd(&IfsOutputIO.Core, "stdout", VDINTERFACETYPE_IO,
1170	NULL, sizeof(VDINTERFACEIO), &pIfsImageOutput);
1171	}
1172	else if (fCreateSparse)
1173	{
1174	IfsOutputIO.pfnOpen = convFileOutOpen;
1175	IfsOutputIO.pfnClose = convFileOutClose;
1176	IfsOutputIO.pfnDelete = convFileOutDelete;
1177	IfsOutputIO.pfnMove = convFileOutMove;
1178	IfsOutputIO.pfnGetFreeSpace = convFileOutGetFreeSpace;
1179	IfsOutputIO.pfnGetModificationTime = convFileOutGetModificationTime;
1180	IfsOutputIO.pfnGetSize = convFileOutGetSize;
1181	IfsOutputIO.pfnSetSize = convFileOutSetSize;
1182	IfsOutputIO.pfnReadSync = convFileOutRead;
1183	IfsOutputIO.pfnWriteSync = convFileOutWrite;
1184	IfsOutputIO.pfnFlushSync = convFileOutFlush;
1185	VDInterfaceAdd(&IfsOutputIO.Core, "fileout", VDINTERFACETYPE_IO,
1186	NULL, sizeof(VDINTERFACEIO), &pIfsImageOutput);
1187	}
1188
1189	/* check the variant parameter */
1190	if (pszVariant)
1191	{
1192	char psz = (char)pszVariant;
1193	while (psz && *psz && RT_SUCCESS(rc))
1194	{
1195	size_t len;
1196	const char *pszComma = strchr(psz, ',');
1197	if (pszComma)
1198	len = pszComma - psz;
1199	else
1200	len = strlen(psz);
1201	if (len > 0)
1202	{
1203	if (!RTStrNICmp(pszVariant, "standard", len))
1204	uImageFlags \|= VD_IMAGE_FLAGS_NONE;
1205	else if (!RTStrNICmp(pszVariant, "fixed", len))
1206	uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
1207	else if (!RTStrNICmp(pszVariant, "split2g", len))
1208	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
1209	else if (!RTStrNICmp(pszVariant, "stream", len))
1210	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED;
1211	else if (!RTStrNICmp(pszVariant, "esx", len))
1212	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_ESX;
1213	else
1214	return errorSyntax("Invalid --variant option\n");
1215	}
1216	if (pszComma)
1217	psz += len + 1;
1218	else
1219	psz += len;
1220	}
1221	}
1222
1223	do
1224	{
1225	/* try to determine input format if not specified */
1226	if (!pszSrcFormat)
1227	{
1228	char *pszFormat = NULL;
1229	VDTYPE enmType = VDTYPE_INVALID;
1230	rc = VDGetFormat(NULL, NULL, pszSrcFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1231	if (RT_FAILURE(rc))
1232	{
1233	errorSyntax("No file format specified, please specify format: %Rrc\n", rc);
1234	break;
1235	}
1236	pszSrcFormat = pszFormat;
1237	enmSrcType = enmType;
1238	}
1239
1240	rc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk);
1241	if (RT_FAILURE(rc))
1242	{
1243	errorRuntime("Error while creating source disk container: %Rrf (%Rrc)\n", rc, rc);
1244	break;
1245	}
1246
1247	rc = VDOpen(pSrcDisk, pszSrcFormat, pszSrcFilename,
1248	VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_SEQUENTIAL,
1249	pIfsImageInput);
1250	if (RT_FAILURE(rc))
1251	{
1252	errorRuntime("Error while opening source image: %Rrf (%Rrc)\n", rc, rc);
1253	break;
1254	}
1255
1256	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDstDisk);
1257	if (RT_FAILURE(rc))
1258	{
1259	errorRuntime("Error while creating the destination disk container: %Rrf (%Rrc)\n", rc, rc);
1260	break;
1261	}
1262
1263	uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
1264	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", pszSrcFilename, cbSize, (cbSize + _1M - 1) / _1M);
1265
1266	/* Create the output image */
1267	rc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, pszDstFormat,
1268	pszDstFilename, false, 0, uImageFlags, NULL,
1269	VD_OPEN_FLAGS_NORMAL \| VD_OPEN_FLAGS_SEQUENTIAL, NULL,
1270	pIfsImageOutput, NULL);
1271	if (RT_FAILURE(rc))
1272	{
1273	errorRuntime("Error while copying the image: %Rrf (%Rrc)\n", rc, rc);
1274	break;
1275	}
1276
1277	}
1278	while (0);
1279
1280	if (pDstDisk)
1281	VDDestroy(pDstDisk);
1282	if (pSrcDisk)
1283	VDDestroy(pSrcDisk);
1284
1285	return RT_SUCCESS(rc) ? 0 : 1;
1286	}
1287
1288
1289	static int handleInfo(HandlerArg *a)
1290	{
1291	int rc = VINF_SUCCESS;
1292	PVDISK pDisk = NULL;
1293	const char *pszFilename = NULL;
1294
1295	/* Parse the command line. */
1296	static const RTGETOPTDEF s_aOptions[] =
1297	{
1298	{ "--filename", 'f', RTGETOPT_REQ_STRING }
1299	};
1300	int ch;
1301	RTGETOPTUNION ValueUnion;
1302	RTGETOPTSTATE GetState;
1303	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1304	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1305	{
1306	switch (ch)
1307	{
1308	case 'f': // --filename
1309	pszFilename = ValueUnion.psz;
1310	break;
1311
1312	default:
1313	ch = RTGetOptPrintError(ch, &ValueUnion);
1314	printUsage(g_pStdErr);
1315	return ch;
1316	}
1317	}
1318
1319	/* Check for mandatory parameters. */
1320	if (!pszFilename)
1321	return errorSyntax("Mandatory --filename option missing\n");
1322
1323	/* just try it */
1324	char *pszFormat = NULL;
1325	VDTYPE enmType = VDTYPE_INVALID;
1326	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1327	if (RT_FAILURE(rc))
1328	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1329
1330	rc = VDCreate(pVDIfs, enmType, &pDisk);
1331	if (RT_FAILURE(rc))
1332	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1333
1334	/* Open the image */
1335	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY, NULL);
1336	RTStrFree(pszFormat);
1337	if (RT_FAILURE(rc))
1338	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1339
1340	VDDumpImages(pDisk);
1341
1342	VDDestroy(pDisk);
1343
1344	return rc;
1345	}
1346
1347
1348	static DECLCALLBACK(int) vboximgQueryBlockStatus(void *pvUser, uint64_t off,
1349	uint64_t cb, bool *pfAllocated)
1350	{
1351	RTVFS hVfs = (RTVFS)pvUser;
1352	return RTVfsQueryRangeState(hVfs, off, cb, pfAllocated);
1353	}
1354
1355
1356	static DECLCALLBACK(int) vboximgQueryRangeUse(void *pvUser, uint64_t off, uint64_t cb,
1357	bool *pfUsed)
1358	{
1359	RTDVM hVolMgr = (RTDVM)pvUser;
1360	return RTDvmMapQueryBlockStatus(hVolMgr, off, cb, pfUsed);
1361	}
1362
1363
1364	typedef struct VBOXIMGVFS
1365	{
1366	/** Pointer to the next VFS handle. */
1367	struct VBOXIMGVFS *pNext;
1368	/** VFS handle. */
1369	RTVFS hVfs;
1370	} VBOXIMGVFS, *PVBOXIMGVFS;
1371
1372	static int handleCompact(HandlerArg *a)
1373	{
1374	PVDISK pDisk = NULL;
1375	VDINTERFACEQUERYRANGEUSE VDIfQueryRangeUse;
1376	PVDINTERFACE pIfsCompact = NULL;
1377	RTDVM hDvm = NIL_RTDVM;
1378	PVBOXIMGVFS pVBoxImgVfsHead = NULL;
1379
1380	/* Parse the command line. */
1381	static const RTGETOPTDEF s_aOptions[] =
1382	{
1383	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1384	{ "--filesystemaware", 'a', RTGETOPT_REQ_NOTHING },
1385	{ "--file-system-aware", 'a', RTGETOPT_REQ_NOTHING },
1386	};
1387
1388	const char *pszFilename = NULL;
1389	bool fFilesystemAware = false;
1390	bool fVerbose = true;
1391
1392	int ch;
1393	RTGETOPTUNION ValueUnion;
1394	RTGETOPTSTATE GetState;
1395	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1396	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1397	{
1398	switch (ch)
1399	{
1400	case 'f': // --filename
1401	pszFilename = ValueUnion.psz;
1402	break;
1403
1404	case 'a':
1405	fFilesystemAware = true;
1406	break;
1407
1408	default:
1409	ch = RTGetOptPrintError(ch, &ValueUnion);
1410	printUsage(g_pStdErr);
1411	return ch;
1412	}
1413	}
1414
1415	/* Check for mandatory parameters. */
1416	if (!pszFilename)
1417	return errorSyntax("Mandatory --filename option missing\n");
1418
1419	/* just try it */
1420	char *pszFormat = NULL;
1421	VDTYPE enmType = VDTYPE_INVALID;
1422	int rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1423	if (RT_FAILURE(rc))
1424	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1425
1426	rc = VDCreate(pVDIfs, enmType, &pDisk);
1427	if (RT_FAILURE(rc))
1428	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1429
1430	/* Open the image */
1431	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
1432	RTStrFree(pszFormat);
1433	if (RT_FAILURE(rc))
1434	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1435
1436	/*
1437	* If --file-system-aware, we first ask the disk volume manager (DVM) to
1438	* find the volumes on the disk.
1439	*/
1440	if ( RT_SUCCESS(rc)
1441	&& fFilesystemAware)
1442	{
1443	RTVFSFILE hVfsDisk;
1444	rc = VDCreateVfsFileFromDisk(pDisk, 0 /fFlags/, &hVfsDisk);
1445	if (RT_SUCCESS(rc))
1446	{
1447	rc = RTDvmCreate(&hDvm, hVfsDisk, 512 /cbSector/, 0 /fFlags/);
1448	RTVfsFileRelease(hVfsDisk);
1449	if (RT_SUCCESS(rc))
1450	{
1451	rc = RTDvmMapOpen(hDvm);
1452	if ( RT_SUCCESS(rc)
1453	&& RTDvmMapGetValidVolumes(hDvm) > 0)
1454	{
1455	/*
1456	* Enumerate the volumes: Try finding a file system interpreter and
1457	* set the block query status callback to work with the FS.
1458	*/
1459	uint32_t iVol = 0;
1460	RTDVMVOLUME hVol;
1461	rc = RTDvmMapQueryFirstVolume(hDvm, &hVol);
1462	AssertRC(rc);
1463
1464	while (RT_SUCCESS(rc))
1465	{
1466	if (fVerbose)
1467	{
1468	char *pszVolName;
1469	rc = RTDvmVolumeQueryName(hVol, &pszVolName);
1470	if (RT_FAILURE(rc))
1471	pszVolName = NULL;
1472	RTMsgInfo("Vol%u: %Rhcb %s%s%s\n", iVol, RTDvmVolumeGetSize(hVol),
1473	RTDvmVolumeTypeGetDescr(RTDvmVolumeGetType(hVol)),
1474	pszVolName ? " " : "", pszVolName ? pszVolName : "");
1475	RTStrFree(pszVolName);
1476	}
1477
1478	RTVFSFILE hVfsFile;
1479	rc = RTDvmVolumeCreateVfsFile(hVol, RTFILE_O_READWRITE, &hVfsFile);
1480	if (RT_FAILURE(rc))
1481	{
1482	errorRuntime("RTDvmVolumeCreateVfsFile failed: %Rrc\n");
1483	break;
1484	}
1485
1486	/* Try to detect the filesystem in this volume. */
1487	RTERRINFOSTATIC ErrInfo;
1488	RTVFS hVfs;
1489	rc = RTVfsMountVol(hVfsFile, RTVFSMNT_F_READ_ONLY \| RTVFSMNT_F_FOR_RANGE_IN_USE, &hVfs,
1490	RTErrInfoInitStatic(&ErrInfo));
1491	RTVfsFileRelease(hVfsFile);
1492	if (RT_SUCCESS(rc))
1493	{
1494	PVBOXIMGVFS pVBoxImgVfs = (PVBOXIMGVFS)RTMemAllocZ(sizeof(VBOXIMGVFS));
1495	if (!pVBoxImgVfs)
1496	{
1497	RTVfsRelease(hVfs);
1498	rc = VERR_NO_MEMORY;
1499	break;
1500	}
1501	pVBoxImgVfs->hVfs = hVfs;
1502	pVBoxImgVfs->pNext = pVBoxImgVfsHead;
1503	pVBoxImgVfsHead = pVBoxImgVfs;
1504	RTDvmVolumeSetQueryBlockStatusCallback(hVol, vboximgQueryBlockStatus, hVfs);
1505	}
1506	else if (rc != VERR_NOT_SUPPORTED)
1507	{
1508	if (RTErrInfoIsSet(&ErrInfo.Core))
1509	errorRuntime("RTVfsMountVol failed: %s\n", ErrInfo.Core.pszMsg);
1510	break;
1511	}
1512	else if (fVerbose && RTErrInfoIsSet(&ErrInfo.Core))
1513	RTMsgInfo("Unsupported file system: %s", ErrInfo.Core.pszMsg);
1514
1515	/*
1516	* Advance. (Releasing hVol here is fine since RTDvmVolumeCreateVfsFile
1517	* retained a reference and the hVfs a reference of it again.)
1518	*/
1519	RTDVMVOLUME hVolNext = NIL_RTDVMVOLUME;
1520	if (RT_SUCCESS(rc))
1521	rc = RTDvmMapQueryNextVolume(hDvm, hVol, &hVolNext);
1522	RTDvmVolumeRelease(hVol);
1523	hVol = hVolNext;
1524	iVol++;
1525	}
1526
1527	if (rc == VERR_DVM_MAP_NO_VOLUME)
1528	rc = VINF_SUCCESS;
1529
1530	if (RT_SUCCESS(rc))
1531	{
1532	VDIfQueryRangeUse.pfnQueryRangeUse = vboximgQueryRangeUse;
1533	VDInterfaceAdd(&VDIfQueryRangeUse.Core, "QueryRangeUse", VDINTERFACETYPE_QUERYRANGEUSE,
1534	hDvm, sizeof(VDINTERFACEQUERYRANGEUSE), &pIfsCompact);
1535	}
1536	}
1537	else if (RT_SUCCESS(rc))
1538	RTPrintf("There are no partitions in the volume map\n");
1539	else if (rc == VERR_NOT_FOUND)
1540	{
1541	RTPrintf("No known volume format on disk found\n");
1542	rc = VINF_SUCCESS;
1543	}
1544	else
1545	errorRuntime("Error while opening the volume manager: %Rrf (%Rrc)\n", rc, rc);
1546	}
1547	else
1548	errorRuntime("Error creating the volume manager: %Rrf (%Rrc)\n", rc, rc);
1549	}
1550	else
1551	errorRuntime("Error while creating VFS interface for the disk: %Rrf (%Rrc)\n", rc, rc);
1552	}
1553
1554	if (RT_SUCCESS(rc))
1555	{
1556	rc = VDCompact(pDisk, 0, pIfsCompact);
1557	if (RT_FAILURE(rc))
1558	errorRuntime("Error while compacting image: %Rrf (%Rrc)\n", rc, rc);
1559	}
1560
1561	while (pVBoxImgVfsHead)
1562	{
1563	PVBOXIMGVFS pVBoxImgVfsFree = pVBoxImgVfsHead;
1564
1565	pVBoxImgVfsHead = pVBoxImgVfsHead->pNext;
1566	RTVfsRelease(pVBoxImgVfsFree->hVfs);
1567	RTMemFree(pVBoxImgVfsFree);
1568	}
1569
1570	if (hDvm)
1571	RTDvmRelease(hDvm);
1572
1573	VDDestroy(pDisk);
1574
1575	return rc;
1576	}
1577
1578
1579	static int handleCreateCache(HandlerArg *a)
1580	{
1581	int rc = VINF_SUCCESS;
1582	PVDISK pDisk = NULL;
1583	const char *pszFilename = NULL;
1584	uint64_t cbSize = 0;
1585
1586	/* Parse the command line. */
1587	static const RTGETOPTDEF s_aOptions[] =
1588	{
1589	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1590	{ "--size", 's', RTGETOPT_REQ_UINT64 }
1591	};
1592	int ch;
1593	RTGETOPTUNION ValueUnion;
1594	RTGETOPTSTATE GetState;
1595	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1596	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1597	{
1598	switch (ch)
1599	{
1600	case 'f': // --filename
1601	pszFilename = ValueUnion.psz;
1602	break;
1603
1604	case 's': // --size
1605	cbSize = ValueUnion.u64;
1606	break;
1607
1608	default:
1609	ch = RTGetOptPrintError(ch, &ValueUnion);
1610	printUsage(g_pStdErr);
1611	return ch;
1612	}
1613	}
1614
1615	/* Check for mandatory parameters. */
1616	if (!pszFilename)
1617	return errorSyntax("Mandatory --filename option missing\n");
1618
1619	if (!cbSize)
1620	return errorSyntax("Mandatory --size option missing\n");
1621
1622	/* just try it */
1623	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1624	if (RT_FAILURE(rc))
1625	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1626
1627	rc = VDCreateCache(pDisk, "VCI", pszFilename, cbSize, VD_IMAGE_FLAGS_DEFAULT,
1628	NULL, NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1629	if (RT_FAILURE(rc))
1630	return errorRuntime("Error while creating the virtual disk cache: %Rrf (%Rrc)\n", rc, rc);
1631
1632	VDDestroy(pDisk);
1633
1634	return rc;
1635	}
1636
1637	static DECLCALLBACK(bool) vdIfCfgCreateBaseAreKeysValid(void pvUser, const char pszzValid)
1638	{
1639	RT_NOREF2(pvUser, pszzValid);
1640	return VINF_SUCCESS; /** @todo Implement. */
1641	}
1642
1643	static DECLCALLBACK(int) vdIfCfgCreateBaseQuerySize(void pvUser, const char pszName, size_t *pcbValue)
1644	{
1645	AssertPtrReturn(pcbValue, VERR_INVALID_POINTER);
1646
1647	AssertPtrReturn(pvUser, VERR_GENERAL_FAILURE);
1648
1649	if (RTStrCmp(pszName, "DataAlignment"))
1650	return VERR_CFGM_VALUE_NOT_FOUND;
1651
1652	pcbValue = strlen((const char )pvUser) + 1 /* include terminator */;
1653
1654	return VINF_SUCCESS;
1655	}
1656
1657	static DECLCALLBACK(int) vdIfCfgCreateBaseQuery(void pvUser, const char pszName, char *pszValue, size_t cchValue)
1658	{
1659	AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
1660
1661	AssertPtrReturn(pvUser, VERR_GENERAL_FAILURE);
1662
1663	if (RTStrCmp(pszName, "DataAlignment"))
1664	return VERR_CFGM_VALUE_NOT_FOUND;
1665
1666	if (strlen((const char *)pvUser) >= cchValue)
1667	return VERR_CFGM_NOT_ENOUGH_SPACE;
1668
1669	memcpy(pszValue, pvUser, strlen((const char *)pvUser) + 1);
1670
1671	return VINF_SUCCESS;
1672
1673	}
1674
1675	static int handleCreateBase(HandlerArg *a)
1676	{
1677	int rc = VINF_SUCCESS;
1678	PVDISK pDisk = NULL;
1679	const char *pszFilename = NULL;
1680	const char *pszBackend = "VDI";
1681	const char *pszVariant = NULL;
1682	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1683	uint64_t cbSize = 0;
1684	const char *pszDataAlignment = NULL;
1685	VDGEOMETRY LCHSGeometry, PCHSGeometry;
1686	PVDINTERFACE pVDIfsOperation = NULL;
1687	VDINTERFACECONFIG vdIfCfg;
1688
1689	memset(&LCHSGeometry, 0, sizeof(LCHSGeometry));
1690	memset(&PCHSGeometry, 0, sizeof(PCHSGeometry));
1691
1692	/* Parse the command line. */
1693	static const RTGETOPTDEF s_aOptions[] =
1694	{
1695	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1696	{ "--size", 's', RTGETOPT_REQ_UINT64 },
1697	{ "--format", 'b', RTGETOPT_REQ_STRING },
1698	{ "--variant", 'v', RTGETOPT_REQ_STRING },
1699	{ "--dataalignment", 'a', RTGETOPT_REQ_STRING }
1700	};
1701	int ch;
1702	RTGETOPTUNION ValueUnion;
1703	RTGETOPTSTATE GetState;
1704	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1705	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1706	{
1707	switch (ch)
1708	{
1709	case 'f': // --filename
1710	pszFilename = ValueUnion.psz;
1711	break;
1712
1713	case 's': // --size
1714	cbSize = ValueUnion.u64;
1715	break;
1716
1717	case 'b': // --format
1718	pszBackend = ValueUnion.psz;
1719	break;
1720
1721	case 'v': // --variant
1722	pszVariant = ValueUnion.psz;
1723	break;
1724
1725	case 'a': // --dataalignment
1726	pszDataAlignment = ValueUnion.psz;
1727	break;
1728
1729	default:
1730	ch = RTGetOptPrintError(ch, &ValueUnion);
1731	printUsage(g_pStdErr);
1732	return ch;
1733	}
1734	}
1735
1736	/* Check for mandatory parameters. */
1737	if (!pszFilename)
1738	return errorSyntax("Mandatory --filename option missing\n");
1739
1740	if (!cbSize)
1741	return errorSyntax("Mandatory --size option missing\n");
1742
1743	if (pszVariant)
1744	{
1745	rc = parseDiskVariant(pszVariant, &uImageFlags);
1746	if (RT_FAILURE(rc))
1747	return errorSyntax("Invalid variant %s given\n", pszVariant);
1748	}
1749
1750	/* Setup the config interface if required. */
1751	if (pszDataAlignment)
1752	{
1753	vdIfCfg.pfnAreKeysValid = vdIfCfgCreateBaseAreKeysValid;
1754	vdIfCfg.pfnQuerySize = vdIfCfgCreateBaseQuerySize;
1755	vdIfCfg.pfnQuery = vdIfCfgCreateBaseQuery;
1756	VDInterfaceAdd(&vdIfCfg.Core, "Config", VDINTERFACETYPE_CONFIG, (void *)pszDataAlignment,
1757	sizeof(vdIfCfg), &pVDIfsOperation);
1758	}
1759
1760	/* just try it */
1761	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1762	if (RT_FAILURE(rc))
1763	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1764
1765	rc = VDCreateBase(pDisk, pszBackend, pszFilename, cbSize, uImageFlags,
1766	NULL, &PCHSGeometry, &LCHSGeometry, NULL, VD_OPEN_FLAGS_NORMAL,
1767	NULL, pVDIfsOperation);
1768	if (RT_FAILURE(rc))
1769	return errorRuntime("Error while creating the virtual disk: %Rrf (%Rrc)\n", rc, rc);
1770
1771	VDDestroy(pDisk);
1772
1773	return rc;
1774	}
1775
1776
1777	static int handleRepair(HandlerArg *a)
1778	{
1779	int rc = VINF_SUCCESS;
1780	const char *pszFilename = NULL;
1781	char *pszBackend = NULL;
1782	const char *pszFormat = NULL;
1783	bool fDryRun = false;
1784	VDTYPE enmType = VDTYPE_HDD;
1785
1786	/* Parse the command line. */
1787	static const RTGETOPTDEF s_aOptions[] =
1788	{
1789	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1790	{ "--dry-run", 'd', RTGETOPT_REQ_NOTHING },
1791	{ "--format", 'b', RTGETOPT_REQ_STRING }
1792	};
1793	int ch;
1794	RTGETOPTUNION ValueUnion;
1795	RTGETOPTSTATE GetState;
1796	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1797	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1798	{
1799	switch (ch)
1800	{
1801	case 'f': // --filename
1802	pszFilename = ValueUnion.psz;
1803	break;
1804
1805	case 'd': // --dry-run
1806	fDryRun = true;
1807	break;
1808
1809	case 'b': // --format
1810	pszFormat = ValueUnion.psz;
1811	break;
1812
1813	default:
1814	ch = RTGetOptPrintError(ch, &ValueUnion);
1815	printUsage(g_pStdErr);
1816	return ch;
1817	}
1818	}
1819
1820	/* Check for mandatory parameters. */
1821	if (!pszFilename)
1822	return errorSyntax("Mandatory --filename option missing\n");
1823
1824	/* just try it */
1825	if (!pszFormat)
1826	{
1827	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszBackend, &enmType);
1828	if (RT_FAILURE(rc))
1829	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1830	pszFormat = pszBackend;
1831	}
1832
1833	rc = VDRepair(pVDIfs, NULL, pszFilename, pszFormat, fDryRun ? VD_REPAIR_DRY_RUN : 0);
1834	if (RT_FAILURE(rc))
1835	rc = errorRuntime("Error while repairing the virtual disk: %Rrf (%Rrc)\n", rc, rc);
1836
1837	if (pszBackend)
1838	RTStrFree(pszBackend);
1839	return rc;
1840	}
1841
1842
1843	static int handleClearComment(HandlerArg *a)
1844	{
1845	int rc = VINF_SUCCESS;
1846	PVDISK pDisk = NULL;
1847	const char *pszFilename = NULL;
1848
1849	/* Parse the command line. */
1850	static const RTGETOPTDEF s_aOptions[] =
1851	{
1852	{ "--filename", 'f', RTGETOPT_REQ_STRING }
1853	};
1854	int ch;
1855	RTGETOPTUNION ValueUnion;
1856	RTGETOPTSTATE GetState;
1857	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1858	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1859	{
1860	switch (ch)
1861	{
1862	case 'f': // --filename
1863	pszFilename = ValueUnion.psz;
1864	break;
1865
1866	default:
1867	ch = RTGetOptPrintError(ch, &ValueUnion);
1868	printUsage(g_pStdErr);
1869	return ch;
1870	}
1871	}
1872
1873	/* Check for mandatory parameters. */
1874	if (!pszFilename)
1875	return errorSyntax("Mandatory --filename option missing\n");
1876
1877	/* just try it */
1878	char *pszFormat = NULL;
1879	VDTYPE enmType = VDTYPE_INVALID;
1880	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1881	if (RT_FAILURE(rc))
1882	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1883
1884	rc = VDCreate(pVDIfs, enmType, &pDisk);
1885	if (RT_FAILURE(rc))
1886	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1887
1888	/* Open the image */
1889	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO, NULL);
1890	if (RT_FAILURE(rc))
1891	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1892
1893	VDSetComment(pDisk, 0, NULL);
1894
1895	VDDestroy(pDisk);
1896	return rc;
1897	}
1898
1899
1900	static int handleCreateFloppy(HandlerArg *a)
1901	{
1902	const char *pszFilename = NULL;
1903	uint64_t cbFloppy = 1474560;
1904	uint16_t cbSector = 0;
1905	uint8_t cHeads = 0;
1906	uint8_t cSectorsPerCluster = 0;
1907	uint8_t cSectorsPerTrack = 0;
1908	uint16_t cRootDirEntries = 0;
1909	uint8_t bMedia = 0;
1910
1911	/* Parse the command line. */
1912	static const RTGETOPTDEF s_aOptions[] =
1913	{
1914	{ "--sectors-per-cluster", 'c', RTGETOPT_REQ_UINT8 },
1915	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1916	{ "--heads", 'h', RTGETOPT_REQ_UINT8 },
1917	{ "--media-byte", 'm', RTGETOPT_REQ_UINT8 },
1918	{ "--root-dir-entries", 'r', RTGETOPT_REQ_UINT16 },
1919	{ "--size", 's', RTGETOPT_REQ_UINT64 },
1920	{ "--sector-size", 'S', RTGETOPT_REQ_UINT16 },
1921	{ "--sectors-per-track", 't', RTGETOPT_REQ_UINT8 },
1922	};
1923	int ch;
1924	RTGETOPTUNION ValueUnion;
1925	RTGETOPTSTATE GetState;
1926	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1927	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1928	{
1929	switch (ch)
1930	{
1931	case 'c': cSectorsPerCluster = ValueUnion.u8; break;
1932	case 'f': pszFilename = ValueUnion.psz; break;
1933	case 'h': cHeads = ValueUnion.u8; break;
1934	case 'm': bMedia = ValueUnion.u8; break;
1935	case 'r': cRootDirEntries = ValueUnion.u16; break;
1936	case 's': cbFloppy = ValueUnion.u64; break;
1937	case 'S': cbSector = ValueUnion.u16; break;
1938	case 't': cSectorsPerTrack = ValueUnion.u8; break;
1939
1940	default:
1941	ch = RTGetOptPrintError(ch, &ValueUnion);
1942	printUsage(g_pStdErr);
1943	return ch;
1944	}
1945	}
1946
1947	/* Check for mandatory parameters. */
1948	if (!pszFilename)
1949	return errorSyntax("Mandatory --filename option missing\n");
1950
1951	/*
1952	* Do the job.
1953	*/
1954	uint32_t offError;
1955	RTERRINFOSTATIC ErrInfo;
1956	RTVFSFILE hVfsFile;
1957	int rc = RTVfsChainOpenFile(pszFilename,
1958	RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_ALL
1959	\| (0770 << RTFILE_O_CREATE_MODE_SHIFT),
1960	&hVfsFile, &offError, RTErrInfoInitStatic(&ErrInfo));
1961	if (RT_SUCCESS(rc))
1962	{
1963	rc = RTFsFatVolFormat(hVfsFile, 0, cbFloppy, RTFSFATVOL_FMT_F_FULL, cbSector, cSectorsPerCluster, RTFSFATTYPE_INVALID,
1964	cHeads, cSectorsPerTrack, bMedia, 0 /cHiddenSectors/, cRootDirEntries,
1965	RTErrInfoInitStatic(&ErrInfo));
1966	RTVfsFileRelease(hVfsFile);
1967	if (RT_SUCCESS(rc))
1968	return RTEXITCODE_SUCCESS;
1969
1970	if (RTErrInfoIsSet(&ErrInfo.Core))
1971	errorRuntime("Error %Rrc formatting floppy '%s': %s", rc, pszFilename, ErrInfo.Core.pszMsg);
1972	else
1973	errorRuntime("Error formatting floppy '%s': %Rrc", pszFilename, rc);
1974	}
1975	else
1976	RTVfsChainMsgError("RTVfsChainOpenFile", pszFilename, rc, offError, &ErrInfo.Core);
1977	return RTEXITCODE_FAILURE;
1978	}
1979
1980
1981	static int handleCreateIso(HandlerArg *a)
1982	{
1983	return RTFsIsoMakerCmd(a->argc + 1, a->argv - 1);
1984	}
1985
1986
1987	static int handleClearResize(HandlerArg *a)
1988	{
1989	int rc = VINF_SUCCESS;
1990	PVDISK pDisk = NULL;
1991	const char *pszFilename = NULL;
1992	uint64_t cbNew = 0;
1993	VDGEOMETRY LCHSGeometry, PCHSGeometry;
1994
1995	memset(&LCHSGeometry, 0, sizeof(LCHSGeometry));
1996	memset(&PCHSGeometry, 0, sizeof(PCHSGeometry));
1997
1998	/* Parse the command line. */
1999	static const RTGETOPTDEF s_aOptions[] =
2000	{
2001	{ "--filename", 'f', RTGETOPT_REQ_STRING },
2002	{ "--size", 's', RTGETOPT_REQ_UINT64 }
2003	};
2004	int ch;
2005	RTGETOPTUNION ValueUnion;
2006	RTGETOPTSTATE GetState;
2007	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
2008	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2009	{
2010	switch (ch)
2011	{
2012	case 'f': // --filename
2013	pszFilename = ValueUnion.psz;
2014	break;
2015
2016	case 's': // --size
2017	cbNew = ValueUnion.u64;
2018	break;
2019
2020	default:
2021	ch = RTGetOptPrintError(ch, &ValueUnion);
2022	printUsage(g_pStdErr);
2023	return ch;
2024	}
2025	}
2026
2027	/* Check for mandatory parameters. */
2028	if (!pszFilename)
2029	return errorSyntax("Mandatory --filename option missing\n");
2030
2031	if (!cbNew)
2032	return errorSyntax("Mandatory --size option missing or invalid\n");
2033
2034	/* just try it */
2035	char *pszFormat = NULL;
2036	VDTYPE enmType = VDTYPE_INVALID;
2037	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
2038	if (RT_FAILURE(rc))
2039	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
2040
2041	rc = VDCreate(pVDIfs, enmType, &pDisk);
2042	if (RT_FAILURE(rc))
2043	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
2044
2045	/* Open the image */
2046	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
2047	if (RT_FAILURE(rc))
2048	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
2049
2050	rc = VDResize(pDisk, cbNew, &PCHSGeometry, &LCHSGeometry, NULL);
2051	if (RT_FAILURE(rc))
2052	rc = errorRuntime("Error while resizing the virtual disk: %Rrf (%Rrc)\n", rc, rc);
2053
2054	VDDestroy(pDisk);
2055	return rc;
2056	}
2057
2058
2059	int main(int argc, char *argv[])
2060	{
2061	int exitcode = 0;
2062
2063	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_STANDALONE_APP);
2064	if (RT_FAILURE(rc))
2065	return RTMsgInitFailure(rc);
2066
2067	g_pszProgName = RTPathFilename(argv[0]);
2068
2069	bool fShowLogo = false;
2070	int iCmd = 1;
2071	int iCmdArg;
2072
2073	/* global options */
2074	for (int i = 1; i < argc \|\| argc <= iCmd; i++)
2075	{
2076	if ( argc <= iCmd
2077	\|\| !strcmp(argv[i], "help")
2078	\|\| !strcmp(argv[i], "-?")
2079	\|\| !strcmp(argv[i], "-h")
2080	\|\| !strcmp(argv[i], "-help")
2081	\|\| !strcmp(argv[i], "--help"))
2082	{
2083	showLogo(g_pStdOut);
2084	printUsage(g_pStdOut);
2085	return 0;
2086	}
2087
2088	if ( !strcmp(argv[i], "-v")
2089	\|\| !strcmp(argv[i], "-version")
2090	\|\| !strcmp(argv[i], "-Version")
2091	\|\| !strcmp(argv[i], "--version"))
2092	{
2093	/* Print version number, and do nothing else. */
2094	RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision());
2095	return 0;
2096	}
2097
2098	if ( !strcmp(argv[i], "--nologo")
2099	\|\| !strcmp(argv[i], "-nologo")
2100	\|\| !strcmp(argv[i], "-q"))
2101	{
2102	/* suppress the logo */
2103	fShowLogo = false;
2104	iCmd++;
2105	}
2106	else
2107	{
2108	break;
2109	}
2110	}
2111
2112	iCmdArg = iCmd + 1;
2113
2114	if (fShowLogo)
2115	showLogo(g_pStdOut);
2116
2117	/* initialize the VD backend with dummy handlers */
2118	VDINTERFACEERROR vdInterfaceError;
2119	vdInterfaceError.pfnError = handleVDError;
2120	vdInterfaceError.pfnMessage = handleVDMessage;
2121
2122	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
2123	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
2124
2125	rc = VDInit();
2126	if (RT_FAILURE(rc))
2127	{
2128	errorSyntax("Initializing backends failed! rc=%Rrc\n", rc);
2129	return 1;
2130	}
2131
2132	/*
2133	* All registered command handlers
2134	*/
2135	static const struct
2136	{
2137	const char *command;
2138	int (handler)(HandlerArg a);
2139	} s_commandHandlers[] =
2140	{
2141	{ "setuuid", handleSetUUID },
2142	{ "geometry", handleGeometry },
2143	{ "convert", handleConvert },
2144	{ "info", handleInfo },
2145	{ "compact", handleCompact },
2146	{ "createcache", handleCreateCache },
2147	{ "createbase", handleCreateBase },
2148	{ "createfloppy", handleCreateFloppy },
2149	{ "createiso", handleCreateIso },
2150	{ "repair", handleRepair },
2151	{ "clearcomment", handleClearComment },
2152	{ "resize", handleClearResize },
2153	{ NULL, NULL }
2154	};
2155
2156	HandlerArg handlerArg = { 0, NULL };
2157	int commandIndex;
2158	for (commandIndex = 0; s_commandHandlers[commandIndex].command != NULL; commandIndex++)
2159	{
2160	if (!strcmp(s_commandHandlers[commandIndex].command, argv[iCmd]))
2161	{
2162	handlerArg.argc = argc - iCmdArg;
2163	handlerArg.argv = &argv[iCmdArg];
2164
2165	exitcode = s_commandHandlers[commandIndex].handler(&handlerArg);
2166	break;
2167	}
2168	}
2169	if (!s_commandHandlers[commandIndex].command)
2170	{
2171	errorSyntax("Invalid command '%s'", argv[iCmd]);
2172	return 1;
2173	}
2174
2175	rc = VDShutdown();
2176	if (RT_FAILURE(rc))
2177	{
2178	errorSyntax("Unloading backends failed! rc=%Rrc\n", rc);
2179	return 1;
2180	}
2181
2182	return exitcode;
2183	}
2184
2185	/* dummy stub for RuntimeR3 */
2186	#ifndef RT_OS_WINDOWS
2187	RTDECL(bool) RTAssertShouldPanic(void)
2188	{
2189	return true;
2190	}
2191	#endif

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

source: vbox/trunk/src/VBox/Storage/testcase/vbox-img.cpp@ 106212

Download in other formats: