vbox-img.cpp@ 57415

Last change on this file since 57415 was 57415, checked in by vboxsync, 9 years ago
More DECLCALLBACK fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.4 KB

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

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

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

Download in other formats: