vbox-img.cpp@ 103005

Last change on this file since 103005 was 103005, checked in by vboxsync, 10 months ago
iprt/asm.h,: Split out the ASMMem and related stuff into a separate header, asm-mem.h, so that we can get the RT_ASM_PAGE_SIZE stuff out of the way.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 70.9 KB

Line
1	/* $Id: vbox-img.cpp 103005 2024-01-23 23:55:58Z vboxsync $ */
2	/** @file
3	* Standalone image manipulation tool
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/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	int rc;
829
830	/* Write the data to the buffer, flushing as required. */
831	size_t cbTotalWritten = 0;
832	do
833	{
834	/* Flush the buffer if we need a new one. */
835	while (uOffset > pFS->offBuffer + sizeof(pFS->abBuffer) - 1)
836	{
837	rc = RTFileWrite(pFS->file, &pFS->abBuffer[0],
838	sizeof(pFS->abBuffer), NULL);
839	RT_ZERO(pFS->abBuffer);
840	pFS->offBuffer += sizeof(pFS->abBuffer);
841	pFS->cbBuffer = 0;
842	}
843
844	uint32_t cbThisWrite = (uint32_t)RT_MIN(cbBuffer,
845	sizeof(pFS->abBuffer) - uOffset % sizeof(pFS->abBuffer));
846	memcpy(&pFS->abBuffer[uOffset % sizeof(pFS->abBuffer)], pvBuffer,
847	cbThisWrite);
848	uOffset += cbThisWrite;
849	pvBuffer = (uint8_t *)pvBuffer + cbThisWrite;
850	cbBuffer -= cbThisWrite;
851	cbTotalWritten += cbThisWrite;
852	} while (cbBuffer > 0);
853
854	if (pcbWritten)
855	*pcbWritten = cbTotalWritten;
856
857	pFS->cbBuffer = uOffset % sizeof(pFS->abBuffer);
858	if (!pFS->cbBuffer)
859	pFS->cbBuffer = sizeof(pFS->abBuffer);
860	pFS->off = uOffset;
861
862	return VINF_SUCCESS;
863	}
864
865	static DECLCALLBACK(int) convStdOutFlush(void pvUser, void pStorage)
866	{
867	NOREF(pvUser);
868	NOREF(pStorage);
869	return VINF_SUCCESS;
870	}
871
872	static DECLCALLBACK(int) convFileOutOpen(void pvUser, const char pszLocation, uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
873	void **ppStorage)
874	{
875	RT_NOREF1(pvUser);
876
877	/* Validate input. */
878	AssertPtrReturn(ppStorage, VERR_INVALID_POINTER);
879	AssertPtrNullReturn(pfnCompleted, VERR_INVALID_PARAMETER);
880	AssertReturn((fOpen & RTFILE_O_ACCESS_MASK) == RTFILE_O_WRITE, VERR_INVALID_PARAMETER);
881	RTFILE file;
882	int rc = RTFileOpen(&file, pszLocation, fOpen);
883	if (RT_FAILURE(rc))
884	return rc;
885
886	/* Must clear buffer, so that skipped over data is initialized properly. */
887	PFILEIOSTATE pFS = (PFILEIOSTATE)RTMemAllocZ(sizeof(FILEIOSTATE));
888	if (!pFS)
889	return VERR_NO_MEMORY;
890
891	pFS->file = file;
892	pFS->cb = 0;
893	pFS->off = 0;
894	pFS->offBuffer = 0;
895	pFS->cbBuffer = sizeof(FILEIOSTATE);
896
897	*ppStorage = pFS;
898	return VINF_SUCCESS;
899	}
900
901	static DECLCALLBACK(int) convFileOutClose(void pvUser, void pStorage)
902	{
903	NOREF(pvUser);
904	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
905	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
906	int rc = VINF_SUCCESS;
907
908	/* Flush any remaining buffer contents. */
909	if (pFS->cbBuffer)
910	rc = RTFileWriteAt(pFS->file, pFS->offBuffer, &pFS->abBuffer[0], pFS->cbBuffer, NULL);
911	RTFileClose(pFS->file);
912
913	RTMemFree(pFS);
914
915	return rc;
916	}
917
918	static DECLCALLBACK(int) convFileOutDelete(void pvUser, const char pcszFilename)
919	{
920	NOREF(pvUser);
921	NOREF(pcszFilename);
922	AssertFailedReturn(VERR_NOT_SUPPORTED);
923	}
924
925	static DECLCALLBACK(int) convFileOutMove(void pvUser, const char pcszSrc, const char *pcszDst, unsigned fMove)
926	{
927	NOREF(pvUser);
928	NOREF(pcszSrc);
929	NOREF(pcszDst);
930	NOREF(fMove);
931	AssertFailedReturn(VERR_NOT_SUPPORTED);
932	}
933
934	static DECLCALLBACK(int) convFileOutGetFreeSpace(void pvUser, const char pcszFilename, int64_t *pcbFreeSpace)
935	{
936	NOREF(pvUser);
937	NOREF(pcszFilename);
938	AssertPtrReturn(pcbFreeSpace, VERR_INVALID_POINTER);
939	*pcbFreeSpace = INT64_MAX;
940	return VINF_SUCCESS;
941	}
942
943	static DECLCALLBACK(int) convFileOutGetModificationTime(void pvUser, const char pcszFilename, PRTTIMESPEC pModificationTime)
944	{
945	NOREF(pvUser);
946	NOREF(pcszFilename);
947	AssertPtrReturn(pModificationTime, VERR_INVALID_POINTER);
948	AssertFailedReturn(VERR_NOT_SUPPORTED);
949	}
950
951	static DECLCALLBACK(int) convFileOutGetSize(void pvUser, void pStorage, uint64_t *pcbSize)
952	{
953	NOREF(pvUser);
954	NOREF(pStorage);
955	AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
956	AssertFailedReturn(VERR_NOT_SUPPORTED);
957	}
958
959	static DECLCALLBACK(int) convFileOutSetSize(void pvUser, void pStorage, uint64_t cbSize)
960	{
961	NOREF(pvUser);
962	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
963	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
964
965	int rc = RTFileSetSize(pFS->file, cbSize);
966	if (RT_SUCCESS(rc))
967	pFS->cb = cbSize;
968	return VINF_SUCCESS;
969	}
970
971	static DECLCALLBACK(int) convFileOutRead(void pvUser, void pStorage, uint64_t uOffset, void *pvBuffer, size_t cbBuffer,
972	size_t *pcbRead)
973	{
974	NOREF(pvUser);
975	NOREF(pStorage);
976	NOREF(uOffset);
977	NOREF(cbBuffer);
978	NOREF(pcbRead);
979	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
980	AssertFailedReturn(VERR_NOT_SUPPORTED);
981	}
982
983	static DECLCALLBACK(int) convFileOutWrite(void pvUser, void pStorage, uint64_t uOffset, const void *pvBuffer, size_t cbBuffer,
984	size_t *pcbWritten)
985	{
986	NOREF(pvUser);
987	AssertPtrReturn(pStorage, VERR_INVALID_POINTER);
988	AssertPtrReturn(pvBuffer, VERR_INVALID_POINTER);
989	PFILEIOSTATE pFS = (PFILEIOSTATE)pStorage;
990	AssertReturn(uOffset >= pFS->off, VERR_INVALID_PARAMETER);
991	int rc;
992
993	/* Write the data to the buffer, flushing as required. */
994	size_t cbTotalWritten = 0;
995	do
996	{
997	/* Flush the buffer if we need a new one. */
998	while (uOffset > pFS->offBuffer + sizeof(pFS->abBuffer) - 1)
999	{
1000	if (!ASMMemIsZero(pFS->abBuffer, sizeof(pFS->abBuffer)))
1001	rc = RTFileWriteAt(pFS->file, pFS->offBuffer,
1002	&pFS->abBuffer[0],
1003	sizeof(pFS->abBuffer), NULL);
1004	RT_ZERO(pFS->abBuffer);
1005	pFS->offBuffer += sizeof(pFS->abBuffer);
1006	pFS->cbBuffer = 0;
1007	}
1008
1009	uint32_t cbThisWrite = (uint32_t)RT_MIN(cbBuffer,
1010	sizeof(pFS->abBuffer) - uOffset % sizeof(pFS->abBuffer));
1011	memcpy(&pFS->abBuffer[uOffset % sizeof(pFS->abBuffer)], pvBuffer,
1012	cbThisWrite);
1013	uOffset += cbThisWrite;
1014	pvBuffer = (uint8_t *)pvBuffer + cbThisWrite;
1015	cbBuffer -= cbThisWrite;
1016	cbTotalWritten += cbThisWrite;
1017	} while (cbBuffer > 0);
1018
1019	if (pcbWritten)
1020	*pcbWritten = cbTotalWritten;
1021
1022	pFS->cbBuffer = uOffset % sizeof(pFS->abBuffer);
1023	if (!pFS->cbBuffer)
1024	pFS->cbBuffer = sizeof(pFS->abBuffer);
1025	pFS->off = uOffset;
1026
1027	return VINF_SUCCESS;
1028	}
1029
1030	static DECLCALLBACK(int) convFileOutFlush(void pvUser, void pStorage)
1031	{
1032	NOREF(pvUser);
1033	NOREF(pStorage);
1034	return VINF_SUCCESS;
1035	}
1036
1037	static int handleConvert(HandlerArg *a)
1038	{
1039	const char *pszSrcFilename = NULL;
1040	const char *pszDstFilename = NULL;
1041	bool fStdIn = false;
1042	bool fStdOut = false;
1043	bool fCreateSparse = false;
1044	const char *pszSrcFormat = NULL;
1045	VDTYPE enmSrcType = VDTYPE_HDD;
1046	const char *pszDstFormat = NULL;
1047	const char *pszVariant = NULL;
1048	PVDISK pSrcDisk = NULL;
1049	PVDISK pDstDisk = NULL;
1050	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1051	PVDINTERFACE pIfsImageInput = NULL;
1052	PVDINTERFACE pIfsImageOutput = NULL;
1053	VDINTERFACEIO IfsInputIO;
1054	VDINTERFACEIO IfsOutputIO;
1055	int rc = VINF_SUCCESS;
1056
1057	/* Parse the command line. */
1058	static const RTGETOPTDEF s_aOptions[] =
1059	{
1060	{ "--srcfilename", 'i', RTGETOPT_REQ_STRING },
1061	{ "--dstfilename", 'o', RTGETOPT_REQ_STRING },
1062	{ "--stdin", 'p', RTGETOPT_REQ_NOTHING },
1063	{ "--stdout", 'P', RTGETOPT_REQ_NOTHING },
1064	{ "--srcformat", 's', RTGETOPT_REQ_STRING },
1065	{ "--dstformat", 'd', RTGETOPT_REQ_STRING },
1066	{ "--variant", 'v', RTGETOPT_REQ_STRING },
1067	{ "--create-sparse", 'c', RTGETOPT_REQ_NOTHING }
1068	};
1069	int ch;
1070	RTGETOPTUNION ValueUnion;
1071	RTGETOPTSTATE GetState;
1072	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1073	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1074	{
1075	switch (ch)
1076	{
1077	case 'i': // --srcfilename
1078	pszSrcFilename = ValueUnion.psz;
1079	break;
1080	case 'o': // --dstfilename
1081	pszDstFilename = ValueUnion.psz;
1082	break;
1083	case 'p': // --stdin
1084	fStdIn = true;
1085	break;
1086	case 'P': // --stdout
1087	fStdOut = true;
1088	break;
1089	case 's': // --srcformat
1090	pszSrcFormat = ValueUnion.psz;
1091	break;
1092	case 'd': // --dstformat
1093	pszDstFormat = ValueUnion.psz;
1094	break;
1095	case 'v': // --variant
1096	pszVariant = ValueUnion.psz;
1097	break;
1098	case 'c': // --create-sparse
1099	fCreateSparse = true;
1100	break;
1101
1102	default:
1103	ch = RTGetOptPrintError(ch, &ValueUnion);
1104	printUsage(g_pStdErr);
1105	return ch;
1106	}
1107	}
1108
1109	/* Check for mandatory parameters and handle dummies/defaults. */
1110	if (fStdIn && !pszSrcFormat)
1111	return errorSyntax("Mandatory --srcformat option missing\n");
1112	if (!pszDstFormat)
1113	pszDstFormat = "VDI";
1114	if (fStdIn && !pszSrcFilename)
1115	{
1116	/* Complete dummy, will be just passed to various calls to fulfill
1117	* the "must be non-NULL" requirement, and is completely ignored
1118	* otherwise. It shown in the stderr message below. */
1119	pszSrcFilename = "stdin";
1120	}
1121	if (fStdOut && !pszDstFilename)
1122	{
1123	/* Will be stored in the destination image if it is a streamOptimized
1124	* VMDK, but it isn't really relevant - use it for "branding". */
1125	if (!RTStrICmp(pszDstFormat, "VMDK"))
1126	pszDstFilename = "VirtualBoxStream.vmdk";
1127	else
1128	pszDstFilename = "stdout";
1129	}
1130	if (!pszSrcFilename)
1131	return errorSyntax("Mandatory --srcfilename option missing\n");
1132	if (!pszDstFilename)
1133	return errorSyntax("Mandatory --dstfilename option missing\n");
1134
1135	if (fStdIn)
1136	{
1137	IfsInputIO.pfnOpen = convInOpen;
1138	IfsInputIO.pfnClose = convInClose;
1139	IfsInputIO.pfnDelete = convInDelete;
1140	IfsInputIO.pfnMove = convInMove;
1141	IfsInputIO.pfnGetFreeSpace = convInGetFreeSpace;
1142	IfsInputIO.pfnGetModificationTime = convInGetModificationTime;
1143	IfsInputIO.pfnGetSize = convInGetSize;
1144	IfsInputIO.pfnSetSize = convInSetSize;
1145	IfsInputIO.pfnReadSync = convInRead;
1146	IfsInputIO.pfnWriteSync = convInWrite;
1147	IfsInputIO.pfnFlushSync = convInFlush;
1148	VDInterfaceAdd(&IfsInputIO.Core, "stdin", VDINTERFACETYPE_IO,
1149	NULL, sizeof(VDINTERFACEIO), &pIfsImageInput);
1150	}
1151	if (fStdOut)
1152	{
1153	IfsOutputIO.pfnOpen = convStdOutOpen;
1154	IfsOutputIO.pfnClose = convStdOutClose;
1155	IfsOutputIO.pfnDelete = convStdOutDelete;
1156	IfsOutputIO.pfnMove = convStdOutMove;
1157	IfsOutputIO.pfnGetFreeSpace = convStdOutGetFreeSpace;
1158	IfsOutputIO.pfnGetModificationTime = convStdOutGetModificationTime;
1159	IfsOutputIO.pfnGetSize = convStdOutGetSize;
1160	IfsOutputIO.pfnSetSize = convStdOutSetSize;
1161	IfsOutputIO.pfnReadSync = convStdOutRead;
1162	IfsOutputIO.pfnWriteSync = convStdOutWrite;
1163	IfsOutputIO.pfnFlushSync = convStdOutFlush;
1164	VDInterfaceAdd(&IfsOutputIO.Core, "stdout", VDINTERFACETYPE_IO,
1165	NULL, sizeof(VDINTERFACEIO), &pIfsImageOutput);
1166	}
1167	else if (fCreateSparse)
1168	{
1169	IfsOutputIO.pfnOpen = convFileOutOpen;
1170	IfsOutputIO.pfnClose = convFileOutClose;
1171	IfsOutputIO.pfnDelete = convFileOutDelete;
1172	IfsOutputIO.pfnMove = convFileOutMove;
1173	IfsOutputIO.pfnGetFreeSpace = convFileOutGetFreeSpace;
1174	IfsOutputIO.pfnGetModificationTime = convFileOutGetModificationTime;
1175	IfsOutputIO.pfnGetSize = convFileOutGetSize;
1176	IfsOutputIO.pfnSetSize = convFileOutSetSize;
1177	IfsOutputIO.pfnReadSync = convFileOutRead;
1178	IfsOutputIO.pfnWriteSync = convFileOutWrite;
1179	IfsOutputIO.pfnFlushSync = convFileOutFlush;
1180	VDInterfaceAdd(&IfsOutputIO.Core, "fileout", VDINTERFACETYPE_IO,
1181	NULL, sizeof(VDINTERFACEIO), &pIfsImageOutput);
1182	}
1183
1184	/* check the variant parameter */
1185	if (pszVariant)
1186	{
1187	char psz = (char)pszVariant;
1188	while (psz && *psz && RT_SUCCESS(rc))
1189	{
1190	size_t len;
1191	const char *pszComma = strchr(psz, ',');
1192	if (pszComma)
1193	len = pszComma - psz;
1194	else
1195	len = strlen(psz);
1196	if (len > 0)
1197	{
1198	if (!RTStrNICmp(pszVariant, "standard", len))
1199	uImageFlags \|= VD_IMAGE_FLAGS_NONE;
1200	else if (!RTStrNICmp(pszVariant, "fixed", len))
1201	uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
1202	else if (!RTStrNICmp(pszVariant, "split2g", len))
1203	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
1204	else if (!RTStrNICmp(pszVariant, "stream", len))
1205	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED;
1206	else if (!RTStrNICmp(pszVariant, "esx", len))
1207	uImageFlags \|= VD_VMDK_IMAGE_FLAGS_ESX;
1208	else
1209	return errorSyntax("Invalid --variant option\n");
1210	}
1211	if (pszComma)
1212	psz += len + 1;
1213	else
1214	psz += len;
1215	}
1216	}
1217
1218	do
1219	{
1220	/* try to determine input format if not specified */
1221	if (!pszSrcFormat)
1222	{
1223	char *pszFormat = NULL;
1224	VDTYPE enmType = VDTYPE_INVALID;
1225	rc = VDGetFormat(NULL, NULL, pszSrcFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1226	if (RT_FAILURE(rc))
1227	{
1228	errorSyntax("No file format specified, please specify format: %Rrc\n", rc);
1229	break;
1230	}
1231	pszSrcFormat = pszFormat;
1232	enmSrcType = enmType;
1233	}
1234
1235	rc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk);
1236	if (RT_FAILURE(rc))
1237	{
1238	errorRuntime("Error while creating source disk container: %Rrf (%Rrc)\n", rc, rc);
1239	break;
1240	}
1241
1242	rc = VDOpen(pSrcDisk, pszSrcFormat, pszSrcFilename,
1243	VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_SEQUENTIAL,
1244	pIfsImageInput);
1245	if (RT_FAILURE(rc))
1246	{
1247	errorRuntime("Error while opening source image: %Rrf (%Rrc)\n", rc, rc);
1248	break;
1249	}
1250
1251	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDstDisk);
1252	if (RT_FAILURE(rc))
1253	{
1254	errorRuntime("Error while creating the destination disk container: %Rrf (%Rrc)\n", rc, rc);
1255	break;
1256	}
1257
1258	uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
1259	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", pszSrcFilename, cbSize, (cbSize + _1M - 1) / _1M);
1260
1261	/* Create the output image */
1262	rc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, pszDstFormat,
1263	pszDstFilename, false, 0, uImageFlags, NULL,
1264	VD_OPEN_FLAGS_NORMAL \| VD_OPEN_FLAGS_SEQUENTIAL, NULL,
1265	pIfsImageOutput, NULL);
1266	if (RT_FAILURE(rc))
1267	{
1268	errorRuntime("Error while copying the image: %Rrf (%Rrc)\n", rc, rc);
1269	break;
1270	}
1271
1272	}
1273	while (0);
1274
1275	if (pDstDisk)
1276	VDDestroy(pDstDisk);
1277	if (pSrcDisk)
1278	VDDestroy(pSrcDisk);
1279
1280	return RT_SUCCESS(rc) ? 0 : 1;
1281	}
1282
1283
1284	static int handleInfo(HandlerArg *a)
1285	{
1286	int rc = VINF_SUCCESS;
1287	PVDISK pDisk = NULL;
1288	const char *pszFilename = NULL;
1289
1290	/* Parse the command line. */
1291	static const RTGETOPTDEF s_aOptions[] =
1292	{
1293	{ "--filename", 'f', RTGETOPT_REQ_STRING }
1294	};
1295	int ch;
1296	RTGETOPTUNION ValueUnion;
1297	RTGETOPTSTATE GetState;
1298	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1299	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1300	{
1301	switch (ch)
1302	{
1303	case 'f': // --filename
1304	pszFilename = ValueUnion.psz;
1305	break;
1306
1307	default:
1308	ch = RTGetOptPrintError(ch, &ValueUnion);
1309	printUsage(g_pStdErr);
1310	return ch;
1311	}
1312	}
1313
1314	/* Check for mandatory parameters. */
1315	if (!pszFilename)
1316	return errorSyntax("Mandatory --filename option missing\n");
1317
1318	/* just try it */
1319	char *pszFormat = NULL;
1320	VDTYPE enmType = VDTYPE_INVALID;
1321	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1322	if (RT_FAILURE(rc))
1323	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1324
1325	rc = VDCreate(pVDIfs, enmType, &pDisk);
1326	if (RT_FAILURE(rc))
1327	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1328
1329	/* Open the image */
1330	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY, NULL);
1331	RTStrFree(pszFormat);
1332	if (RT_FAILURE(rc))
1333	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1334
1335	VDDumpImages(pDisk);
1336
1337	VDDestroy(pDisk);
1338
1339	return rc;
1340	}
1341
1342
1343	static DECLCALLBACK(int) vboximgQueryBlockStatus(void *pvUser, uint64_t off,
1344	uint64_t cb, bool *pfAllocated)
1345	{
1346	RTVFS hVfs = (RTVFS)pvUser;
1347	return RTVfsQueryRangeState(hVfs, off, cb, pfAllocated);
1348	}
1349
1350
1351	static DECLCALLBACK(int) vboximgQueryRangeUse(void *pvUser, uint64_t off, uint64_t cb,
1352	bool *pfUsed)
1353	{
1354	RTDVM hVolMgr = (RTDVM)pvUser;
1355	return RTDvmMapQueryBlockStatus(hVolMgr, off, cb, pfUsed);
1356	}
1357
1358
1359	typedef struct VBOXIMGVFS
1360	{
1361	/** Pointer to the next VFS handle. */
1362	struct VBOXIMGVFS *pNext;
1363	/** VFS handle. */
1364	RTVFS hVfs;
1365	} VBOXIMGVFS, *PVBOXIMGVFS;
1366
1367	static int handleCompact(HandlerArg *a)
1368	{
1369	PVDISK pDisk = NULL;
1370	VDINTERFACEQUERYRANGEUSE VDIfQueryRangeUse;
1371	PVDINTERFACE pIfsCompact = NULL;
1372	RTDVM hDvm = NIL_RTDVM;
1373	PVBOXIMGVFS pVBoxImgVfsHead = NULL;
1374
1375	/* Parse the command line. */
1376	static const RTGETOPTDEF s_aOptions[] =
1377	{
1378	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1379	{ "--filesystemaware", 'a', RTGETOPT_REQ_NOTHING },
1380	{ "--file-system-aware", 'a', RTGETOPT_REQ_NOTHING },
1381	};
1382
1383	const char *pszFilename = NULL;
1384	bool fFilesystemAware = false;
1385	bool fVerbose = true;
1386
1387	int ch;
1388	RTGETOPTUNION ValueUnion;
1389	RTGETOPTSTATE GetState;
1390	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1391	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1392	{
1393	switch (ch)
1394	{
1395	case 'f': // --filename
1396	pszFilename = ValueUnion.psz;
1397	break;
1398
1399	case 'a':
1400	fFilesystemAware = true;
1401	break;
1402
1403	default:
1404	ch = RTGetOptPrintError(ch, &ValueUnion);
1405	printUsage(g_pStdErr);
1406	return ch;
1407	}
1408	}
1409
1410	/* Check for mandatory parameters. */
1411	if (!pszFilename)
1412	return errorSyntax("Mandatory --filename option missing\n");
1413
1414	/* just try it */
1415	char *pszFormat = NULL;
1416	VDTYPE enmType = VDTYPE_INVALID;
1417	int rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1418	if (RT_FAILURE(rc))
1419	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1420
1421	rc = VDCreate(pVDIfs, enmType, &pDisk);
1422	if (RT_FAILURE(rc))
1423	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1424
1425	/* Open the image */
1426	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
1427	RTStrFree(pszFormat);
1428	if (RT_FAILURE(rc))
1429	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1430
1431	/*
1432	* If --file-system-aware, we first ask the disk volume manager (DVM) to
1433	* find the volumes on the disk.
1434	*/
1435	if ( RT_SUCCESS(rc)
1436	&& fFilesystemAware)
1437	{
1438	RTVFSFILE hVfsDisk;
1439	rc = VDCreateVfsFileFromDisk(pDisk, 0 /fFlags/, &hVfsDisk);
1440	if (RT_SUCCESS(rc))
1441	{
1442	rc = RTDvmCreate(&hDvm, hVfsDisk, 512 /cbSector/, 0 /fFlags/);
1443	RTVfsFileRelease(hVfsDisk);
1444	if (RT_SUCCESS(rc))
1445	{
1446	rc = RTDvmMapOpen(hDvm);
1447	if ( RT_SUCCESS(rc)
1448	&& RTDvmMapGetValidVolumes(hDvm) > 0)
1449	{
1450	/*
1451	* Enumerate the volumes: Try finding a file system interpreter and
1452	* set the block query status callback to work with the FS.
1453	*/
1454	uint32_t iVol = 0;
1455	RTDVMVOLUME hVol;
1456	rc = RTDvmMapQueryFirstVolume(hDvm, &hVol);
1457	AssertRC(rc);
1458
1459	while (RT_SUCCESS(rc))
1460	{
1461	if (fVerbose)
1462	{
1463	char *pszVolName;
1464	rc = RTDvmVolumeQueryName(hVol, &pszVolName);
1465	if (RT_FAILURE(rc))
1466	pszVolName = NULL;
1467	RTMsgInfo("Vol%u: %Rhcb %s%s%s\n", iVol, RTDvmVolumeGetSize(hVol),
1468	RTDvmVolumeTypeGetDescr(RTDvmVolumeGetType(hVol)),
1469	pszVolName ? " " : "", pszVolName ? pszVolName : "");
1470	RTStrFree(pszVolName);
1471	}
1472
1473	RTVFSFILE hVfsFile;
1474	rc = RTDvmVolumeCreateVfsFile(hVol, RTFILE_O_READWRITE, &hVfsFile);
1475	if (RT_FAILURE(rc))
1476	{
1477	errorRuntime("RTDvmVolumeCreateVfsFile failed: %Rrc\n");
1478	break;
1479	}
1480
1481	/* Try to detect the filesystem in this volume. */
1482	RTERRINFOSTATIC ErrInfo;
1483	RTVFS hVfs;
1484	rc = RTVfsMountVol(hVfsFile, RTVFSMNT_F_READ_ONLY \| RTVFSMNT_F_FOR_RANGE_IN_USE, &hVfs,
1485	RTErrInfoInitStatic(&ErrInfo));
1486	RTVfsFileRelease(hVfsFile);
1487	if (RT_SUCCESS(rc))
1488	{
1489	PVBOXIMGVFS pVBoxImgVfs = (PVBOXIMGVFS)RTMemAllocZ(sizeof(VBOXIMGVFS));
1490	if (!pVBoxImgVfs)
1491	{
1492	RTVfsRelease(hVfs);
1493	rc = VERR_NO_MEMORY;
1494	break;
1495	}
1496	pVBoxImgVfs->hVfs = hVfs;
1497	pVBoxImgVfs->pNext = pVBoxImgVfsHead;
1498	pVBoxImgVfsHead = pVBoxImgVfs;
1499	RTDvmVolumeSetQueryBlockStatusCallback(hVol, vboximgQueryBlockStatus, hVfs);
1500	}
1501	else if (rc != VERR_NOT_SUPPORTED)
1502	{
1503	if (RTErrInfoIsSet(&ErrInfo.Core))
1504	errorRuntime("RTVfsMountVol failed: %s\n", ErrInfo.Core.pszMsg);
1505	break;
1506	}
1507	else if (fVerbose && RTErrInfoIsSet(&ErrInfo.Core))
1508	RTMsgInfo("Unsupported file system: %s", ErrInfo.Core.pszMsg);
1509
1510	/*
1511	* Advance. (Releasing hVol here is fine since RTDvmVolumeCreateVfsFile
1512	* retained a reference and the hVfs a reference of it again.)
1513	*/
1514	RTDVMVOLUME hVolNext = NIL_RTDVMVOLUME;
1515	if (RT_SUCCESS(rc))
1516	rc = RTDvmMapQueryNextVolume(hDvm, hVol, &hVolNext);
1517	RTDvmVolumeRelease(hVol);
1518	hVol = hVolNext;
1519	iVol++;
1520	}
1521
1522	if (rc == VERR_DVM_MAP_NO_VOLUME)
1523	rc = VINF_SUCCESS;
1524
1525	if (RT_SUCCESS(rc))
1526	{
1527	VDIfQueryRangeUse.pfnQueryRangeUse = vboximgQueryRangeUse;
1528	VDInterfaceAdd(&VDIfQueryRangeUse.Core, "QueryRangeUse", VDINTERFACETYPE_QUERYRANGEUSE,
1529	hDvm, sizeof(VDINTERFACEQUERYRANGEUSE), &pIfsCompact);
1530	}
1531	}
1532	else if (RT_SUCCESS(rc))
1533	RTPrintf("There are no partitions in the volume map\n");
1534	else if (rc == VERR_NOT_FOUND)
1535	{
1536	RTPrintf("No known volume format on disk found\n");
1537	rc = VINF_SUCCESS;
1538	}
1539	else
1540	errorRuntime("Error while opening the volume manager: %Rrf (%Rrc)\n", rc, rc);
1541	}
1542	else
1543	errorRuntime("Error creating the volume manager: %Rrf (%Rrc)\n", rc, rc);
1544	}
1545	else
1546	errorRuntime("Error while creating VFS interface for the disk: %Rrf (%Rrc)\n", rc, rc);
1547	}
1548
1549	if (RT_SUCCESS(rc))
1550	{
1551	rc = VDCompact(pDisk, 0, pIfsCompact);
1552	if (RT_FAILURE(rc))
1553	errorRuntime("Error while compacting image: %Rrf (%Rrc)\n", rc, rc);
1554	}
1555
1556	while (pVBoxImgVfsHead)
1557	{
1558	PVBOXIMGVFS pVBoxImgVfsFree = pVBoxImgVfsHead;
1559
1560	pVBoxImgVfsHead = pVBoxImgVfsHead->pNext;
1561	RTVfsRelease(pVBoxImgVfsFree->hVfs);
1562	RTMemFree(pVBoxImgVfsFree);
1563	}
1564
1565	if (hDvm)
1566	RTDvmRelease(hDvm);
1567
1568	VDDestroy(pDisk);
1569
1570	return rc;
1571	}
1572
1573
1574	static int handleCreateCache(HandlerArg *a)
1575	{
1576	int rc = VINF_SUCCESS;
1577	PVDISK pDisk = NULL;
1578	const char *pszFilename = NULL;
1579	uint64_t cbSize = 0;
1580
1581	/* Parse the command line. */
1582	static const RTGETOPTDEF s_aOptions[] =
1583	{
1584	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1585	{ "--size", 's', RTGETOPT_REQ_UINT64 }
1586	};
1587	int ch;
1588	RTGETOPTUNION ValueUnion;
1589	RTGETOPTSTATE GetState;
1590	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1591	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1592	{
1593	switch (ch)
1594	{
1595	case 'f': // --filename
1596	pszFilename = ValueUnion.psz;
1597	break;
1598
1599	case 's': // --size
1600	cbSize = ValueUnion.u64;
1601	break;
1602
1603	default:
1604	ch = RTGetOptPrintError(ch, &ValueUnion);
1605	printUsage(g_pStdErr);
1606	return ch;
1607	}
1608	}
1609
1610	/* Check for mandatory parameters. */
1611	if (!pszFilename)
1612	return errorSyntax("Mandatory --filename option missing\n");
1613
1614	if (!cbSize)
1615	return errorSyntax("Mandatory --size option missing\n");
1616
1617	/* just try it */
1618	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1619	if (RT_FAILURE(rc))
1620	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1621
1622	rc = VDCreateCache(pDisk, "VCI", pszFilename, cbSize, VD_IMAGE_FLAGS_DEFAULT,
1623	NULL, NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1624	if (RT_FAILURE(rc))
1625	return errorRuntime("Error while creating the virtual disk cache: %Rrf (%Rrc)\n", rc, rc);
1626
1627	VDDestroy(pDisk);
1628
1629	return rc;
1630	}
1631
1632	static DECLCALLBACK(bool) vdIfCfgCreateBaseAreKeysValid(void pvUser, const char pszzValid)
1633	{
1634	RT_NOREF2(pvUser, pszzValid);
1635	return VINF_SUCCESS; /** @todo Implement. */
1636	}
1637
1638	static DECLCALLBACK(int) vdIfCfgCreateBaseQuerySize(void pvUser, const char pszName, size_t *pcbValue)
1639	{
1640	AssertPtrReturn(pcbValue, VERR_INVALID_POINTER);
1641
1642	AssertPtrReturn(pvUser, VERR_GENERAL_FAILURE);
1643
1644	if (RTStrCmp(pszName, "DataAlignment"))
1645	return VERR_CFGM_VALUE_NOT_FOUND;
1646
1647	pcbValue = strlen((const char )pvUser) + 1 /* include terminator */;
1648
1649	return VINF_SUCCESS;
1650	}
1651
1652	static DECLCALLBACK(int) vdIfCfgCreateBaseQuery(void pvUser, const char pszName, char *pszValue, size_t cchValue)
1653	{
1654	AssertPtrReturn(pszValue, VERR_INVALID_POINTER);
1655
1656	AssertPtrReturn(pvUser, VERR_GENERAL_FAILURE);
1657
1658	if (RTStrCmp(pszName, "DataAlignment"))
1659	return VERR_CFGM_VALUE_NOT_FOUND;
1660
1661	if (strlen((const char *)pvUser) >= cchValue)
1662	return VERR_CFGM_NOT_ENOUGH_SPACE;
1663
1664	memcpy(pszValue, pvUser, strlen((const char *)pvUser) + 1);
1665
1666	return VINF_SUCCESS;
1667
1668	}
1669
1670	static int handleCreateBase(HandlerArg *a)
1671	{
1672	int rc = VINF_SUCCESS;
1673	PVDISK pDisk = NULL;
1674	const char *pszFilename = NULL;
1675	const char *pszBackend = "VDI";
1676	const char *pszVariant = NULL;
1677	unsigned uImageFlags = VD_IMAGE_FLAGS_NONE;
1678	uint64_t cbSize = 0;
1679	const char *pszDataAlignment = NULL;
1680	VDGEOMETRY LCHSGeometry, PCHSGeometry;
1681	PVDINTERFACE pVDIfsOperation = NULL;
1682	VDINTERFACECONFIG vdIfCfg;
1683
1684	memset(&LCHSGeometry, 0, sizeof(LCHSGeometry));
1685	memset(&PCHSGeometry, 0, sizeof(PCHSGeometry));
1686
1687	/* Parse the command line. */
1688	static const RTGETOPTDEF s_aOptions[] =
1689	{
1690	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1691	{ "--size", 's', RTGETOPT_REQ_UINT64 },
1692	{ "--format", 'b', RTGETOPT_REQ_STRING },
1693	{ "--variant", 'v', RTGETOPT_REQ_STRING },
1694	{ "--dataalignment", 'a', RTGETOPT_REQ_STRING }
1695	};
1696	int ch;
1697	RTGETOPTUNION ValueUnion;
1698	RTGETOPTSTATE GetState;
1699	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1700	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1701	{
1702	switch (ch)
1703	{
1704	case 'f': // --filename
1705	pszFilename = ValueUnion.psz;
1706	break;
1707
1708	case 's': // --size
1709	cbSize = ValueUnion.u64;
1710	break;
1711
1712	case 'b': // --format
1713	pszBackend = ValueUnion.psz;
1714	break;
1715
1716	case 'v': // --variant
1717	pszVariant = ValueUnion.psz;
1718	break;
1719
1720	case 'a': // --dataalignment
1721	pszDataAlignment = ValueUnion.psz;
1722	break;
1723
1724	default:
1725	ch = RTGetOptPrintError(ch, &ValueUnion);
1726	printUsage(g_pStdErr);
1727	return ch;
1728	}
1729	}
1730
1731	/* Check for mandatory parameters. */
1732	if (!pszFilename)
1733	return errorSyntax("Mandatory --filename option missing\n");
1734
1735	if (!cbSize)
1736	return errorSyntax("Mandatory --size option missing\n");
1737
1738	if (pszVariant)
1739	{
1740	rc = parseDiskVariant(pszVariant, &uImageFlags);
1741	if (RT_FAILURE(rc))
1742	return errorSyntax("Invalid variant %s given\n", pszVariant);
1743	}
1744
1745	/* Setup the config interface if required. */
1746	if (pszDataAlignment)
1747	{
1748	vdIfCfg.pfnAreKeysValid = vdIfCfgCreateBaseAreKeysValid;
1749	vdIfCfg.pfnQuerySize = vdIfCfgCreateBaseQuerySize;
1750	vdIfCfg.pfnQuery = vdIfCfgCreateBaseQuery;
1751	VDInterfaceAdd(&vdIfCfg.Core, "Config", VDINTERFACETYPE_CONFIG, (void *)pszDataAlignment,
1752	sizeof(vdIfCfg), &pVDIfsOperation);
1753	}
1754
1755	/* just try it */
1756	rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1757	if (RT_FAILURE(rc))
1758	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1759
1760	rc = VDCreateBase(pDisk, pszBackend, pszFilename, cbSize, uImageFlags,
1761	NULL, &PCHSGeometry, &LCHSGeometry, NULL, VD_OPEN_FLAGS_NORMAL,
1762	NULL, pVDIfsOperation);
1763	if (RT_FAILURE(rc))
1764	return errorRuntime("Error while creating the virtual disk: %Rrf (%Rrc)\n", rc, rc);
1765
1766	VDDestroy(pDisk);
1767
1768	return rc;
1769	}
1770
1771
1772	static int handleRepair(HandlerArg *a)
1773	{
1774	int rc = VINF_SUCCESS;
1775	const char *pszFilename = NULL;
1776	char *pszBackend = NULL;
1777	const char *pszFormat = NULL;
1778	bool fDryRun = false;
1779	VDTYPE enmType = VDTYPE_HDD;
1780
1781	/* Parse the command line. */
1782	static const RTGETOPTDEF s_aOptions[] =
1783	{
1784	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1785	{ "--dry-run", 'd', RTGETOPT_REQ_NOTHING },
1786	{ "--format", 'b', RTGETOPT_REQ_STRING }
1787	};
1788	int ch;
1789	RTGETOPTUNION ValueUnion;
1790	RTGETOPTSTATE GetState;
1791	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1792	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1793	{
1794	switch (ch)
1795	{
1796	case 'f': // --filename
1797	pszFilename = ValueUnion.psz;
1798	break;
1799
1800	case 'd': // --dry-run
1801	fDryRun = true;
1802	break;
1803
1804	case 'b': // --format
1805	pszFormat = ValueUnion.psz;
1806	break;
1807
1808	default:
1809	ch = RTGetOptPrintError(ch, &ValueUnion);
1810	printUsage(g_pStdErr);
1811	return ch;
1812	}
1813	}
1814
1815	/* Check for mandatory parameters. */
1816	if (!pszFilename)
1817	return errorSyntax("Mandatory --filename option missing\n");
1818
1819	/* just try it */
1820	if (!pszFormat)
1821	{
1822	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszBackend, &enmType);
1823	if (RT_FAILURE(rc))
1824	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1825	pszFormat = pszBackend;
1826	}
1827
1828	rc = VDRepair(pVDIfs, NULL, pszFilename, pszFormat, fDryRun ? VD_REPAIR_DRY_RUN : 0);
1829	if (RT_FAILURE(rc))
1830	rc = errorRuntime("Error while repairing the virtual disk: %Rrf (%Rrc)\n", rc, rc);
1831
1832	if (pszBackend)
1833	RTStrFree(pszBackend);
1834	return rc;
1835	}
1836
1837
1838	static int handleClearComment(HandlerArg *a)
1839	{
1840	int rc = VINF_SUCCESS;
1841	PVDISK pDisk = NULL;
1842	const char *pszFilename = NULL;
1843
1844	/* Parse the command line. */
1845	static const RTGETOPTDEF s_aOptions[] =
1846	{
1847	{ "--filename", 'f', RTGETOPT_REQ_STRING }
1848	};
1849	int ch;
1850	RTGETOPTUNION ValueUnion;
1851	RTGETOPTSTATE GetState;
1852	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
1853	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1854	{
1855	switch (ch)
1856	{
1857	case 'f': // --filename
1858	pszFilename = ValueUnion.psz;
1859	break;
1860
1861	default:
1862	ch = RTGetOptPrintError(ch, &ValueUnion);
1863	printUsage(g_pStdErr);
1864	return ch;
1865	}
1866	}
1867
1868	/* Check for mandatory parameters. */
1869	if (!pszFilename)
1870	return errorSyntax("Mandatory --filename option missing\n");
1871
1872	/* just try it */
1873	char *pszFormat = NULL;
1874	VDTYPE enmType = VDTYPE_INVALID;
1875	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
1876	if (RT_FAILURE(rc))
1877	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
1878
1879	rc = VDCreate(pVDIfs, enmType, &pDisk);
1880	if (RT_FAILURE(rc))
1881	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
1882
1883	/* Open the image */
1884	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_INFO, NULL);
1885	if (RT_FAILURE(rc))
1886	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
1887
1888	VDSetComment(pDisk, 0, NULL);
1889
1890	VDDestroy(pDisk);
1891	return rc;
1892	}
1893
1894
1895	static int handleCreateFloppy(HandlerArg *a)
1896	{
1897	const char *pszFilename = NULL;
1898	uint64_t cbFloppy = 1474560;
1899	uint16_t cbSector = 0;
1900	uint8_t cHeads = 0;
1901	uint8_t cSectorsPerCluster = 0;
1902	uint8_t cSectorsPerTrack = 0;
1903	uint16_t cRootDirEntries = 0;
1904	uint8_t bMedia = 0;
1905
1906	/* Parse the command line. */
1907	static const RTGETOPTDEF s_aOptions[] =
1908	{
1909	{ "--sectors-per-cluster", 'c', RTGETOPT_REQ_UINT8 },
1910	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1911	{ "--heads", 'h', RTGETOPT_REQ_UINT8 },
1912	{ "--media-byte", 'm', RTGETOPT_REQ_UINT8 },
1913	{ "--root-dir-entries", 'r', RTGETOPT_REQ_UINT16 },
1914	{ "--size", 's', RTGETOPT_REQ_UINT64 },
1915	{ "--sector-size", 'S', RTGETOPT_REQ_UINT16 },
1916	{ "--sectors-per-track", 't', RTGETOPT_REQ_UINT8 },
1917	};
1918	int ch;
1919	RTGETOPTUNION ValueUnion;
1920	RTGETOPTSTATE GetState;
1921	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1922	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1923	{
1924	switch (ch)
1925	{
1926	case 'c': cSectorsPerCluster = ValueUnion.u8; break;
1927	case 'f': pszFilename = ValueUnion.psz; break;
1928	case 'h': cHeads = ValueUnion.u8; break;
1929	case 'm': bMedia = ValueUnion.u8; break;
1930	case 'r': cRootDirEntries = ValueUnion.u16; break;
1931	case 's': cbFloppy = ValueUnion.u64; break;
1932	case 'S': cbSector = ValueUnion.u16; break;
1933	case 't': cSectorsPerTrack = ValueUnion.u8; break;
1934
1935	default:
1936	ch = RTGetOptPrintError(ch, &ValueUnion);
1937	printUsage(g_pStdErr);
1938	return ch;
1939	}
1940	}
1941
1942	/* Check for mandatory parameters. */
1943	if (!pszFilename)
1944	return errorSyntax("Mandatory --filename option missing\n");
1945
1946	/*
1947	* Do the job.
1948	*/
1949	uint32_t offError;
1950	RTERRINFOSTATIC ErrInfo;
1951	RTVFSFILE hVfsFile;
1952	int rc = RTVfsChainOpenFile(pszFilename,
1953	RTFILE_O_WRITE \| RTFILE_O_CREATE_REPLACE \| RTFILE_O_DENY_ALL
1954	\| (0770 << RTFILE_O_CREATE_MODE_SHIFT),
1955	&hVfsFile, &offError, RTErrInfoInitStatic(&ErrInfo));
1956	if (RT_SUCCESS(rc))
1957	{
1958	rc = RTFsFatVolFormat(hVfsFile, 0, cbFloppy, RTFSFATVOL_FMT_F_FULL, cbSector, cSectorsPerCluster, RTFSFATTYPE_INVALID,
1959	cHeads, cSectorsPerTrack, bMedia, 0 /cHiddenSectors/, cRootDirEntries,
1960	RTErrInfoInitStatic(&ErrInfo));
1961	RTVfsFileRelease(hVfsFile);
1962	if (RT_SUCCESS(rc))
1963	return RTEXITCODE_SUCCESS;
1964
1965	if (RTErrInfoIsSet(&ErrInfo.Core))
1966	errorRuntime("Error %Rrc formatting floppy '%s': %s", rc, pszFilename, ErrInfo.Core.pszMsg);
1967	else
1968	errorRuntime("Error formatting floppy '%s': %Rrc", pszFilename, rc);
1969	}
1970	else
1971	RTVfsChainMsgError("RTVfsChainOpenFile", pszFilename, rc, offError, &ErrInfo.Core);
1972	return RTEXITCODE_FAILURE;
1973	}
1974
1975
1976	static int handleCreateIso(HandlerArg *a)
1977	{
1978	return RTFsIsoMakerCmd(a->argc + 1, a->argv - 1);
1979	}
1980
1981
1982	static int handleClearResize(HandlerArg *a)
1983	{
1984	int rc = VINF_SUCCESS;
1985	PVDISK pDisk = NULL;
1986	const char *pszFilename = NULL;
1987	uint64_t cbNew = 0;
1988	VDGEOMETRY LCHSGeometry, PCHSGeometry;
1989
1990	memset(&LCHSGeometry, 0, sizeof(LCHSGeometry));
1991	memset(&PCHSGeometry, 0, sizeof(PCHSGeometry));
1992
1993	/* Parse the command line. */
1994	static const RTGETOPTDEF s_aOptions[] =
1995	{
1996	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1997	{ "--size", 's', RTGETOPT_REQ_UINT64 }
1998	};
1999	int ch;
2000	RTGETOPTUNION ValueUnion;
2001	RTGETOPTSTATE GetState;
2002	RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0 /* fFlags */);
2003	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2004	{
2005	switch (ch)
2006	{
2007	case 'f': // --filename
2008	pszFilename = ValueUnion.psz;
2009	break;
2010
2011	case 's': // --size
2012	cbNew = ValueUnion.u64;
2013	break;
2014
2015	default:
2016	ch = RTGetOptPrintError(ch, &ValueUnion);
2017	printUsage(g_pStdErr);
2018	return ch;
2019	}
2020	}
2021
2022	/* Check for mandatory parameters. */
2023	if (!pszFilename)
2024	return errorSyntax("Mandatory --filename option missing\n");
2025
2026	if (!cbNew)
2027	return errorSyntax("Mandatory --size option missing or invalid\n");
2028
2029	/* just try it */
2030	char *pszFormat = NULL;
2031	VDTYPE enmType = VDTYPE_INVALID;
2032	rc = VDGetFormat(NULL, NULL, pszFilename, VDTYPE_INVALID, &pszFormat, &enmType);
2033	if (RT_FAILURE(rc))
2034	return errorSyntax("Format autodetect failed: %Rrc\n", rc);
2035
2036	rc = VDCreate(pVDIfs, enmType, &pDisk);
2037	if (RT_FAILURE(rc))
2038	return errorRuntime("Error while creating the virtual disk container: %Rrf (%Rrc)\n", rc, rc);
2039
2040	/* Open the image */
2041	rc = VDOpen(pDisk, pszFormat, pszFilename, VD_OPEN_FLAGS_NORMAL, NULL);
2042	if (RT_FAILURE(rc))
2043	return errorRuntime("Error while opening the image: %Rrf (%Rrc)\n", rc, rc);
2044
2045	rc = VDResize(pDisk, cbNew, &PCHSGeometry, &LCHSGeometry, NULL);
2046	if (RT_FAILURE(rc))
2047	rc = errorRuntime("Error while resizing the virtual disk: %Rrf (%Rrc)\n", rc, rc);
2048
2049	VDDestroy(pDisk);
2050	return rc;
2051	}
2052
2053
2054	int main(int argc, char *argv[])
2055	{
2056	int exitcode = 0;
2057
2058	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_STANDALONE_APP);
2059	if (RT_FAILURE(rc))
2060	return RTMsgInitFailure(rc);
2061
2062	g_pszProgName = RTPathFilename(argv[0]);
2063
2064	bool fShowLogo = false;
2065	int iCmd = 1;
2066	int iCmdArg;
2067
2068	/* global options */
2069	for (int i = 1; i < argc \|\| argc <= iCmd; i++)
2070	{
2071	if ( argc <= iCmd
2072	\|\| !strcmp(argv[i], "help")
2073	\|\| !strcmp(argv[i], "-?")
2074	\|\| !strcmp(argv[i], "-h")
2075	\|\| !strcmp(argv[i], "-help")
2076	\|\| !strcmp(argv[i], "--help"))
2077	{
2078	showLogo(g_pStdOut);
2079	printUsage(g_pStdOut);
2080	return 0;
2081	}
2082
2083	if ( !strcmp(argv[i], "-v")
2084	\|\| !strcmp(argv[i], "-version")
2085	\|\| !strcmp(argv[i], "-Version")
2086	\|\| !strcmp(argv[i], "--version"))
2087	{
2088	/* Print version number, and do nothing else. */
2089	RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision());
2090	return 0;
2091	}
2092
2093	if ( !strcmp(argv[i], "--nologo")
2094	\|\| !strcmp(argv[i], "-nologo")
2095	\|\| !strcmp(argv[i], "-q"))
2096	{
2097	/* suppress the logo */
2098	fShowLogo = false;
2099	iCmd++;
2100	}
2101	else
2102	{
2103	break;
2104	}
2105	}
2106
2107	iCmdArg = iCmd + 1;
2108
2109	if (fShowLogo)
2110	showLogo(g_pStdOut);
2111
2112	/* initialize the VD backend with dummy handlers */
2113	VDINTERFACEERROR vdInterfaceError;
2114	vdInterfaceError.pfnError = handleVDError;
2115	vdInterfaceError.pfnMessage = handleVDMessage;
2116
2117	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
2118	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
2119
2120	rc = VDInit();
2121	if (RT_FAILURE(rc))
2122	{
2123	errorSyntax("Initializing backends failed! rc=%Rrc\n", rc);
2124	return 1;
2125	}
2126
2127	/*
2128	* All registered command handlers
2129	*/
2130	static const struct
2131	{
2132	const char *command;
2133	int (handler)(HandlerArg a);
2134	} s_commandHandlers[] =
2135	{
2136	{ "setuuid", handleSetUUID },
2137	{ "geometry", handleGeometry },
2138	{ "convert", handleConvert },
2139	{ "info", handleInfo },
2140	{ "compact", handleCompact },
2141	{ "createcache", handleCreateCache },
2142	{ "createbase", handleCreateBase },
2143	{ "createfloppy", handleCreateFloppy },
2144	{ "createiso", handleCreateIso },
2145	{ "repair", handleRepair },
2146	{ "clearcomment", handleClearComment },
2147	{ "resize", handleClearResize },
2148	{ NULL, NULL }
2149	};
2150
2151	HandlerArg handlerArg = { 0, NULL };
2152	int commandIndex;
2153	for (commandIndex = 0; s_commandHandlers[commandIndex].command != NULL; commandIndex++)
2154	{
2155	if (!strcmp(s_commandHandlers[commandIndex].command, argv[iCmd]))
2156	{
2157	handlerArg.argc = argc - iCmdArg;
2158	handlerArg.argv = &argv[iCmdArg];
2159
2160	exitcode = s_commandHandlers[commandIndex].handler(&handlerArg);
2161	break;
2162	}
2163	}
2164	if (!s_commandHandlers[commandIndex].command)
2165	{
2166	errorSyntax("Invalid command '%s'", argv[iCmd]);
2167	return 1;
2168	}
2169
2170	rc = VDShutdown();
2171	if (RT_FAILURE(rc))
2172	{
2173	errorSyntax("Unloading backends failed! rc=%Rrc\n", rc);
2174	return 1;
2175	}
2176
2177	return exitcode;
2178	}
2179
2180	/* dummy stub for RuntimeR3 */
2181	#ifndef RT_OS_WINDOWS
2182	RTDECL(bool) RTAssertShouldPanic(void)
2183	{
2184	return true;
2185	}
2186	#endif

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

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

Download in other formats: