VBoxInternalManage.cpp@ 33082

Last change on this file since 33082 was 33082, checked in by vboxsync, 14 years ago
Storage/VBoxHDD: allow specifying the open mode explicitly, it makes no sense to copy the open mode (even with the readonly hacks we had)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.7 KB

Line
1	/* $Id: VBoxInternalManage.cpp 33082 2010-10-12 20:26:27Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'internalcommands' command.
4	*
5	* VBoxInternalManage used to be a second CLI for doing special tricks,
6	* not intended for general usage, only for assisting VBox developers.
7	* It is now integrated into VBoxManage.
8	*/
9
10	/*
11	* Copyright (C) 2006-2010 Oracle Corporation
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*/
21
22
23
24	/*******************************************************************************
25	* Header Files *
26	*******************************************************************************/
27	#include <VBox/com/com.h>
28	#include <VBox/com/string.h>
29	#include <VBox/com/Guid.h>
30	#include <VBox/com/ErrorInfo.h>
31	#include <VBox/com/errorprint.h>
32
33	#include <VBox/com/VirtualBox.h>
34
35	#include <VBox/VBoxHDD.h>
36	#include <VBox/sup.h>
37	#include <VBox/err.h>
38	#include <VBox/log.h>
39
40	#include <iprt/file.h>
41	#include <iprt/getopt.h>
42	#include <iprt/stream.h>
43	#include <iprt/string.h>
44	#include <iprt/uuid.h>
45
46
47	#include "VBoxManage.h"
48
49	/* Includes for the raw disk stuff. */
50	#ifdef RT_OS_WINDOWS
51	# include <windows.h>
52	# include <winioctl.h>
53	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \
54	\|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
55	# include <errno.h>
56	# include <sys/ioctl.h>
57	# include <sys/types.h>
58	# include <sys/stat.h>
59	# include <fcntl.h>
60	# include <unistd.h>
61	#endif
62	#ifdef RT_OS_LINUX
63	# include <sys/utsname.h>
64	# include <linux/hdreg.h>
65	# include <linux/fs.h>
66	# include <stdlib.h> /* atoi() */
67	#endif /* RT_OS_LINUX */
68	#ifdef RT_OS_DARWIN
69	# include <sys/disk.h>
70	#endif /* RT_OS_DARWIN */
71	#ifdef RT_OS_SOLARIS
72	# include <stropts.h>
73	# include <sys/dkio.h>
74	# include <sys/vtoc.h>
75	#endif /* RT_OS_SOLARIS */
76	#ifdef RT_OS_FREEBSD
77	# include <sys/disk.h>
78	#endif /* RT_OS_FREEBSD */
79
80	using namespace com;
81
82
83	/** Macro for checking whether a partition is of extended type or not. */
84	#define PARTTYPE_IS_EXTENDED(x) ((x) == 0x05 \|\| (x) == 0x0f \|\| (x) == 0x85)
85
86	/** Maximum number of partitions we can deal with.
87	* Ridiculously large number, but the memory consumption is rather low so who
88	* cares about never using most entries. */
89	#define HOSTPARTITION_MAX 100
90
91
92	typedef struct HOSTPARTITION
93	{
94	unsigned uIndex;
95	/** partition type */
96	unsigned uType;
97	/** CHS/cylinder of the first sector */
98	unsigned uStartCylinder;
99	/** CHS/head of the first sector */
100	unsigned uStartHead;
101	/** CHS/head of the first sector */
102	unsigned uStartSector;
103	/** CHS/cylinder of the last sector */
104	unsigned uEndCylinder;
105	/** CHS/head of the last sector */
106	unsigned uEndHead;
107	/** CHS/sector of the last sector */
108	unsigned uEndSector;
109	/** start sector of this partition relative to the beginning of the hard
110	* disk or relative to the beginning of the extended partition table */
111	uint64_t uStart;
112	/** numer of sectors of the partition */
113	uint64_t uSize;
114	/** start sector of this partition _table_ */
115	uint64_t uPartDataStart;
116	/** numer of sectors of this partition _table_ */
117	uint64_t cPartDataSectors;
118	} HOSTPARTITION, *PHOSTPARTITION;
119
120	typedef struct HOSTPARTITIONS
121	{
122	unsigned cPartitions;
123	HOSTPARTITION aPartitions[HOSTPARTITION_MAX];
124	} HOSTPARTITIONS, *PHOSTPARTITIONS;
125
126	/** flag whether we're in internal mode */
127	bool g_fInternalMode;
128
129	/**
130	* Print the usage info.
131	*/
132	void printUsageInternal(USAGECATEGORY u64Cmd, PRTSTREAM pStrm)
133	{
134	RTStrmPrintf(pStrm,
135	"Usage: VBoxManage internalcommands <command> [command arguments]\n"
136	"\n"
137	"Commands:\n"
138	"\n"
139	"%s%s%s%s%s%s%s%s%s%s%s%s"
140	"WARNING: This is a development tool and shall only be used to analyse\n"
141	" problems. It is completely unsupported and will change in\n"
142	" incompatible ways without warning.\n",
143
144	(u64Cmd & USAGE_LOADSYMS)
145	? " loadsyms <vmname>\|<uuid> <symfile> [delta] [module] [module address]\n"
146	" This will instruct DBGF to load the given symbolfile\n"
147	" during initialization.\n"
148	"\n"
149	: "",
150	(u64Cmd & USAGE_UNLOADSYMS)
151	? " unloadsyms <vmname>\|<uuid> <symfile>\n"
152	" Removes <symfile> from the list of symbol files that\n"
153	" should be loaded during DBF initialization.\n"
154	"\n"
155	: "",
156	(u64Cmd & USAGE_SETHDUUID)
157	? " sethduuid <filepath> [<uuid>]\n"
158	" Assigns a new UUID to the given image file. This way, multiple copies\n"
159	" of a container can be registered.\n"
160	"\n"
161	: "",
162	(u64Cmd & USAGE_SETHDPARENTUUID)
163	? " sethdparentuuid <filepath> <uuid>\n"
164	" Assigns a new parent UUID to the given image file.\n"
165	"\n"
166	: "",
167	(u64Cmd & USAGE_DUMPHDINFO)
168	? " dumphdinfo <filepath>\n"
169	" Prints information about the image at the given location.\n"
170	"\n"
171	: "",
172	(u64Cmd & USAGE_LISTPARTITIONS)
173	? " listpartitions -rawdisk <diskname>\n"
174	" Lists all partitions on <diskname>.\n"
175	"\n"
176	: "",
177	(u64Cmd & USAGE_CREATERAWVMDK)
178	? " createrawvmdk -filename <filename> -rawdisk <diskname>\n"
179	" [-partitions <list of partition numbers> [-mbr <filename>] ]\n"
180	" [-register] [-relative]\n"
181	" Creates a new VMDK image which gives access to an entite host disk (if\n"
182	" the parameter -partitions is not specified) or some partitions of a\n"
183	" host disk. If access to individual partitions is granted, then the\n"
184	" parameter -mbr can be used to specify an alternative MBR to be used\n"
185	" (the partitioning information in the MBR file is ignored).\n"
186	" The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n"
187	" \\\\.\\PhysicalDrive0).\n"
188	" On Linux host the parameter -relative causes a VMDK file to be created\n"
189	" which refers to individual partitions instead to the entire disk.\n"
190	" Optionally the created image can be immediately registered.\n"
191	" The necessary partition numbers can be queried with\n"
192	" VBoxManage internalcommands listpartitions\n"
193	"\n"
194	: "",
195	(u64Cmd & USAGE_RENAMEVMDK)
196	? " renamevmdk -from <filename> -to <filename>\n"
197	" Renames an existing VMDK image, including the base file and all its extents.\n"
198	"\n"
199	: "",
200	(u64Cmd & USAGE_CONVERTTORAW)
201	? " converttoraw [-format <fileformat>] <filename> <outputfile>"
202	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
203	"\|stdout"
204	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
205	"\n"
206	" Convert image to raw, writing to file"
207	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
208	" or stdout"
209	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
210	".\n"
211	"\n"
212	: "",
213	(u64Cmd & USAGE_CONVERTHD)
214	? " converthd [-srcformat VDI\|VMDK\|VHD\|RAW]\n"
215	" [-dstformat VDI\|VMDK\|VHD\|RAW]\n"
216	" <inputfile> <outputfile>\n"
217	" converts hard disk images between formats\n"
218	"\n"
219	: "",
220	#ifdef RT_OS_WINDOWS
221	(u64Cmd & USAGE_MODINSTALL)
222	? " modinstall\n"
223	" Installs the neccessary driver for the host OS\n"
224	"\n"
225	: "",
226	(u64Cmd & USAGE_MODUNINSTALL)
227	? " moduninstall\n"
228	" Deinstalls the driver\n"
229	"\n"
230	: "",
231	#else
232	"",
233	"",
234	#endif
235	(u64Cmd & USAGE_DEBUGLOG)
236	? " debuglog <vmname>\|<uuid> [--enable\|--disable] [--flags todo]\n"
237	" [--groups todo] [--destinations todo]\n"
238	" Controls debug logging.\n"
239	"\n"
240	: ""
241	);
242	}
243
244	/** @todo this is no longer necessary, we can enumerate extra data */
245	/**
246	* Finds a new unique key name.
247	*
248	* I don't think this is 100% race condition proof, but we assumes
249	* the user is not trying to push this point.
250	*
251	* @returns Result from the insert.
252	* @param pMachine The Machine object.
253	* @param pszKeyBase The base key.
254	* @param rKey Reference to the string object in which we will return the key.
255	*/
256	static HRESULT NewUniqueKey(ComPtr<IMachine> pMachine, const char *pszKeyBase, Utf8Str &rKey)
257	{
258	Bstr KeyBase(pszKeyBase);
259	Bstr Keys;
260	HRESULT hrc = pMachine->GetExtraData(KeyBase.raw(), Keys.asOutParam());
261	if (FAILED(hrc))
262	return hrc;
263
264	/* if there are no keys, it's simple. */
265	if (Keys.isEmpty())
266	{
267	rKey = "1";
268	return pMachine->SetExtraData(KeyBase.raw(), Bstr(rKey).raw());
269	}
270
271	/* find a unique number - brute force rulez. */
272	Utf8Str KeysUtf8(Keys);
273	const char *pszKeys = RTStrStripL(KeysUtf8.c_str());
274	for (unsigned i = 1; i < 1000000; i++)
275	{
276	char szKey[32];
277	size_t cchKey = RTStrPrintf(szKey, sizeof(szKey), "%#x", i);
278	const char *psz = strstr(pszKeys, szKey);
279	while (psz)
280	{
281	if ( ( psz == pszKeys
282	\|\| psz[-1] == ' ')
283	&& ( psz[cchKey] == ' '
284	\|\| !psz[cchKey])
285	)
286	break;
287	psz = strstr(psz + cchKey, szKey);
288	}
289	if (!psz)
290	{
291	rKey = szKey;
292	Utf8StrFmt NewKeysUtf8("%s %s", pszKeys, szKey);
293	return pMachine->SetExtraData(KeyBase.raw(),
294	Bstr(NewKeysUtf8).raw());
295	}
296	}
297	RTMsgError("Cannot find unique key for '%s'!", pszKeyBase);
298	return E_FAIL;
299	}
300
301
302	#if 0
303	/**
304	* Remove a key.
305	*
306	* I don't think this isn't 100% race condition proof, but we assumes
307	* the user is not trying to push this point.
308	*
309	* @returns Result from the insert.
310	* @param pMachine The machine object.
311	* @param pszKeyBase The base key.
312	* @param pszKey The key to remove.
313	*/
314	static HRESULT RemoveKey(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey)
315	{
316	Bstr Keys;
317	HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam());
318	if (FAILED(hrc))
319	return hrc;
320
321	/* if there are no keys, it's simple. */
322	if (Keys.isEmpty())
323	return S_OK;
324
325	char *pszKeys;
326	int rc = RTUtf16ToUtf8(Keys.raw(), &pszKeys);
327	if (RT_SUCCESS(rc))
328	{
329	/* locate it */
330	size_t cchKey = strlen(pszKey);
331	char *psz = strstr(pszKeys, pszKey);
332	while (psz)
333	{
334	if ( ( psz == pszKeys
335	\|\| psz[-1] == ' ')
336	&& ( psz[cchKey] == ' '
337	\|\| !psz[cchKey])
338	)
339	break;
340	psz = strstr(psz + cchKey, pszKey);
341	}
342	if (psz)
343	{
344	/* remove it */
345	char *pszNext = RTStrStripL(psz + cchKey);
346	if (*pszNext)
347	memmove(psz, pszNext, strlen(pszNext) + 1);
348	else
349	*psz = '\0';
350	psz = RTStrStrip(pszKeys);
351
352	/* update */
353	hrc = pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(psz));
354	}
355
356	RTStrFree(pszKeys);
357	return hrc;
358	}
359	else
360	RTMsgError("Failed to delete key '%s' from '%s', string conversion error %Rrc!",
361	pszKey, pszKeyBase, rc);
362
363	return E_FAIL;
364	}
365	#endif
366
367
368	/**
369	* Sets a key value, does necessary error bitching.
370	*
371	* @returns COM status code.
372	* @param pMachine The Machine object.
373	* @param pszKeyBase The key base.
374	* @param pszKey The key.
375	* @param pszAttribute The attribute name.
376	* @param pszValue The string value.
377	*/
378	static HRESULT SetString(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char pszAttribute, const char pszValue)
379	{
380	HRESULT hrc = pMachine->SetExtraData(BstrFmt("%s/%s/%s", pszKeyBase,
381	pszKey, pszAttribute).raw(),
382	Bstr(pszValue).raw());
383	if (FAILED(hrc))
384	RTMsgError("Failed to set '%s/%s/%s' to '%s'! hrc=%#x",
385	pszKeyBase, pszKey, pszAttribute, pszValue, hrc);
386	return hrc;
387	}
388
389
390	/**
391	* Sets a key value, does necessary error bitching.
392	*
393	* @returns COM status code.
394	* @param pMachine The Machine object.
395	* @param pszKeyBase The key base.
396	* @param pszKey The key.
397	* @param pszAttribute The attribute name.
398	* @param u64Value The value.
399	*/
400	static HRESULT SetUInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, uint64_t u64Value)
401	{
402	char szValue[64];
403	RTStrPrintf(szValue, sizeof(szValue), "%#RX64", u64Value);
404	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
405	}
406
407
408	/**
409	* Sets a key value, does necessary error bitching.
410	*
411	* @returns COM status code.
412	* @param pMachine The Machine object.
413	* @param pszKeyBase The key base.
414	* @param pszKey The key.
415	* @param pszAttribute The attribute name.
416	* @param i64Value The value.
417	*/
418	static HRESULT SetInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, int64_t i64Value)
419	{
420	char szValue[64];
421	RTStrPrintf(szValue, sizeof(szValue), "%RI64", i64Value);
422	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
423	}
424
425
426	/**
427	* Identical to the 'loadsyms' command.
428	*/
429	static int CmdLoadSyms(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
430	{
431	HRESULT rc;
432
433	/*
434	* Get the VM
435	*/
436	ComPtr<IMachine> machine;
437	/* assume it's a UUID */
438	rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(), machine.asOutParam());
439	if (FAILED(rc) \|\| !machine)
440	{
441	/* must be a name */
442	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
443	machine.asOutParam()), 1);
444	}
445
446	/*
447	* Parse the command.
448	*/
449	const char *pszFilename;
450	int64_t offDelta = 0;
451	const char *pszModule = NULL;
452	uint64_t ModuleAddress = ~0;
453	uint64_t ModuleSize = 0;
454
455	/* filename */
456	if (argc < 2)
457	return errorArgument("Missing the filename argument!\n");
458	pszFilename = argv[1];
459
460	/* offDelta */
461	if (argc >= 3)
462	{
463	int irc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
464	if (RT_FAILURE(irc))
465	return errorArgument(argv[0], "Failed to read delta '%s', rc=%Rrc\n", argv[2], rc);
466	}
467
468	/* pszModule */
469	if (argc >= 4)
470	pszModule = argv[3];
471
472	/* ModuleAddress */
473	if (argc >= 5)
474	{
475	int irc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
476	if (RT_FAILURE(irc))
477	return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[4], rc);
478	}
479
480	/* ModuleSize */
481	if (argc >= 6)
482	{
483	int irc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
484	if (RT_FAILURE(irc))
485	return errorArgument(argv[0], "Failed to read module size '%s', rc=%Rrc\n", argv[5], rc);
486	}
487
488	/*
489	* Add extra data.
490	*/
491	Utf8Str KeyStr;
492	HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
493	if (SUCCEEDED(hrc))
494	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Filename", pszFilename);
495	if (SUCCEEDED(hrc) && argc >= 3)
496	hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Delta", offDelta);
497	if (SUCCEEDED(hrc) && argc >= 4)
498	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Module", pszModule);
499	if (SUCCEEDED(hrc) && argc >= 5)
500	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleAddress", ModuleAddress);
501	if (SUCCEEDED(hrc) && argc >= 6)
502	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleSize", ModuleSize);
503
504	return FAILED(hrc);
505	}
506
507
508	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
509	{
510	RTMsgErrorV(pszFormat, va);
511	RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
512	}
513
514	static int handleVDMessage(void pvUser, const char pszFormat, va_list va)
515	{
516	NOREF(pvUser);
517	return RTPrintfV(pszFormat, va);
518	}
519
520	static int CmdSetHDUUID(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
521	{
522	Guid uuid;
523	RTUUID rtuuid;
524	enum eUuidType {
525	HDUUID,
526	HDPARENTUUID
527	} uuidType;
528
529	if (!strcmp(argv[0], "sethduuid"))
530	{
531	uuidType = HDUUID;
532	if (argc != 3 && argc != 2)
533	return errorSyntax(USAGE_SETHDUUID, "Not enough parameters");
534	/* if specified, take UUID, otherwise generate a new one */
535	if (argc == 3)
536	{
537	if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
538	return errorSyntax(USAGE_SETHDUUID, "Invalid UUID parameter");
539	uuid = argv[2];
540	} else
541	uuid.create();
542	}
543	else if (!strcmp(argv[0], "sethdparentuuid"))
544	{
545	uuidType = HDPARENTUUID;
546	if (argc != 3)
547	return errorSyntax(USAGE_SETHDPARENTUUID, "Not enough parameters");
548	if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
549	return errorSyntax(USAGE_SETHDPARENTUUID, "Invalid UUID parameter");
550	uuid = argv[2];
551	}
552	else
553	return errorSyntax(USAGE_SETHDUUID, "Invalid invocation");
554
555	/* just try it */
556	char *pszFormat = NULL;
557	int rc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
558	argv[1], &pszFormat);
559	if (RT_FAILURE(rc))
560	{
561	RTMsgError("Format autodetect failed: %Rrc", rc);
562	return 1;
563	}
564
565	PVBOXHDD pDisk = NULL;
566
567	PVDINTERFACE pVDIfs = NULL;
568	VDINTERFACE vdInterfaceError;
569	VDINTERFACEERROR vdInterfaceErrorCallbacks;
570	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
571	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
572	vdInterfaceErrorCallbacks.pfnError = handleVDError;
573	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
574
575	rc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
576	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
577	AssertRC(rc);
578
579	rc = VDCreate(pVDIfs, &pDisk);
580	if (RT_FAILURE(rc))
581	{
582	RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
583	return 1;
584	}
585
586	/* Open the image */
587	rc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL, NULL);
588	if (RT_FAILURE(rc))
589	{
590	RTMsgError("Cannot open the image: %Rrc", rc);
591	return 1;
592	}
593
594	if (uuidType == HDUUID)
595	rc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
596	else
597	rc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
598	if (RT_FAILURE(rc))
599	RTMsgError("Cannot set a new UUID: %Rrc", rc);
600	else
601	RTPrintf("UUID changed to: %s\n", uuid.toString().c_str());
602
603	VDCloseAll(pDisk);
604
605	return RT_FAILURE(rc);
606	}
607
608
609	static int CmdDumpHDInfo(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
610	{
611	/* we need exactly one parameter: the image file */
612	if (argc != 1)
613	{
614	return errorSyntax(USAGE_DUMPHDINFO, "Not enough parameters");
615	}
616
617	/* just try it */
618	char *pszFormat = NULL;
619	int rc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
620	argv[0], &pszFormat);
621	if (RT_FAILURE(rc))
622	{
623	RTMsgError("Format autodetect failed: %Rrc", rc);
624	return 1;
625	}
626
627	PVBOXHDD pDisk = NULL;
628
629	PVDINTERFACE pVDIfs = NULL;
630	VDINTERFACE vdInterfaceError;
631	VDINTERFACEERROR vdInterfaceErrorCallbacks;
632	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
633	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
634	vdInterfaceErrorCallbacks.pfnError = handleVDError;
635	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
636
637	rc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
638	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
639	AssertRC(rc);
640
641	rc = VDCreate(pVDIfs, &pDisk);
642	if (RT_FAILURE(rc))
643	{
644	RTMsgError("Cannot create the virtual disk container: %Rrc", rc);
645	return 1;
646	}
647
648	/* Open the image */
649	rc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_INFO, NULL);
650	if (RT_FAILURE(rc))
651	{
652	RTMsgError("Cannot open the image: %Rrc", rc);
653	return 1;
654	}
655
656	VDDumpImages(pDisk);
657
658	VDCloseAll(pDisk);
659
660	return RT_FAILURE(rc);
661	}
662
663	static int partRead(RTFILE File, PHOSTPARTITIONS pPart)
664	{
665	uint8_t aBuffer[512];
666	int rc;
667
668	pPart->cPartitions = 0;
669	memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions));
670	rc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL);
671	if (RT_FAILURE(rc))
672	return rc;
673	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
674	return VERR_INVALID_PARAMETER;
675
676	unsigned uExtended = (unsigned)-1;
677
678	for (unsigned i = 0; i < 4; i++)
679	{
680	uint8_t p = &aBuffer[0x1be + i 16];
681	if (p[4] == 0)
682	continue;
683	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
684	pCP->uIndex = i + 1;
685	pCP->uType = p[4];
686	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
687	pCP->uStartHead = p[1];
688	pCP->uStartSector = p[2] & 0x3f;
689	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
690	pCP->uEndHead = p[5];
691	pCP->uEndSector = p[6] & 0x3f;
692	pCP->uStart = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
693	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
694	pCP->uPartDataStart = 0; /* will be filled out later properly. */
695	pCP->cPartDataSectors = 0;
696
697	if (PARTTYPE_IS_EXTENDED(p[4]))
698	{
699	if (uExtended == (unsigned)-1)
700	uExtended = (unsigned)(pCP - pPart->aPartitions);
701	else
702	{
703	RTMsgError("More than one extended partition");
704	return VERR_INVALID_PARAMETER;
705	}
706	}
707	}
708
709	if (uExtended != (unsigned)-1)
710	{
711	unsigned uIndex = 5;
712	uint64_t uStart = pPart->aPartitions[uExtended].uStart;
713	uint64_t uOffset = 0;
714	if (!uStart)
715	{
716	RTMsgError("Inconsistency for logical partition start");
717	return VERR_INVALID_PARAMETER;
718	}
719
720	do
721	{
722	rc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL);
723	if (RT_FAILURE(rc))
724	return rc;
725
726	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
727	{
728	RTMsgError("Logical partition without magic");
729	return VERR_INVALID_PARAMETER;
730	}
731	uint8_t *p = &aBuffer[0x1be];
732
733	if (p[4] == 0)
734	{
735	RTMsgError("Logical partition with type 0 encountered");
736	return VERR_INVALID_PARAMETER;
737	}
738
739	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
740	pCP->uIndex = uIndex;
741	pCP->uType = p[4];
742	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
743	pCP->uStartHead = p[1];
744	pCP->uStartSector = p[2] & 0x3f;
745	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
746	pCP->uEndHead = p[5];
747	pCP->uEndSector = p[6] & 0x3f;
748	uint32_t uStartOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
749	if (!uStartOffset)
750	{
751	RTMsgError("Invalid partition start offset");
752	return VERR_INVALID_PARAMETER;
753	}
754	pCP->uStart = uStart + uOffset + uStartOffset;
755	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
756	/* Fill out partitioning location info for EBR. */
757	pCP->uPartDataStart = uStart + uOffset;
758	pCP->cPartDataSectors = uStartOffset;
759	p += 16;
760	if (p[4] == 0)
761	uExtended = (unsigned)-1;
762	else if (PARTTYPE_IS_EXTENDED(p[4]))
763	{
764	uExtended = uIndex++;
765	uOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
766	}
767	else
768	{
769	RTMsgError("Logical partition chain broken");
770	return VERR_INVALID_PARAMETER;
771	}
772	} while (uExtended != (unsigned)-1);
773	}
774
775	/* Sort partitions in ascending order of start sector, plus a trivial
776	* bit of consistency checking. */
777	for (unsigned i = 0; i < pPart->cPartitions-1; i++)
778	{
779	unsigned uMinIdx = i;
780	uint64_t uMinVal = pPart->aPartitions[i].uStart;
781	for (unsigned j = i + 1; j < pPart->cPartitions; j++)
782	{
783	if (pPart->aPartitions[j].uStart < uMinVal)
784	{
785	uMinIdx = j;
786	uMinVal = pPart->aPartitions[j].uStart;
787	}
788	else if (pPart->aPartitions[j].uStart == uMinVal)
789	{
790	RTMsgError("Two partitions start at the same place");
791	return VERR_INVALID_PARAMETER;
792	}
793	else if (pPart->aPartitions[j].uStart == 0)
794	{
795	RTMsgError("Partition starts at sector 0");
796	return VERR_INVALID_PARAMETER;
797	}
798	}
799	if (uMinIdx != i)
800	{
801	/* Swap entries at index i and uMinIdx. */
802	memcpy(&pPart->aPartitions[pPart->cPartitions],
803	&pPart->aPartitions[i], sizeof(HOSTPARTITION));
804	memcpy(&pPart->aPartitions[i],
805	&pPart->aPartitions[uMinIdx], sizeof(HOSTPARTITION));
806	memcpy(&pPart->aPartitions[uMinIdx],
807	&pPart->aPartitions[pPart->cPartitions], sizeof(HOSTPARTITION));
808	}
809	}
810
811	/* Fill out partitioning location info for MBR. */
812	pPart->aPartitions[0].uPartDataStart = 0;
813	pPart->aPartitions[0].cPartDataSectors = pPart->aPartitions[0].uStart;
814
815	/* Now do a some partition table consistency checking, to reject the most
816	* obvious garbage which can lead to trouble later. */
817	uint64_t uPrevEnd = 0;
818	for (unsigned i = 0; i < pPart->cPartitions-1; i++)
819	{
820	if (pPart->aPartitions[i].cPartDataSectors)
821	uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors;
822	if (pPart->aPartitions[i].uStart < uPrevEnd)
823	{
824	RTMsgError("Overlapping partitions");
825	return VERR_INVALID_PARAMETER;
826	}
827	if (!PARTTYPE_IS_EXTENDED(pPart->aPartitions[i].uType))
828	uPrevEnd = pPart->aPartitions[i].uStart + pPart->aPartitions[i].uSize;
829	}
830
831	return VINF_SUCCESS;
832	}
833
834	static int CmdListPartitions(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
835	{
836	Utf8Str rawdisk;
837
838	/* let's have a closer look at the arguments */
839	for (int i = 0; i < argc; i++)
840	{
841	if (strcmp(argv[i], "-rawdisk") == 0)
842	{
843	if (argc <= i + 1)
844	{
845	return errorArgument("Missing argument to '%s'", argv[i]);
846	}
847	i++;
848	rawdisk = argv[i];
849	}
850	else
851	{
852	return errorSyntax(USAGE_LISTPARTITIONS, "Invalid parameter '%s'", argv[i]);
853	}
854	}
855
856	if (rawdisk.isEmpty())
857	return errorSyntax(USAGE_LISTPARTITIONS, "Mandatory parameter -rawdisk missing");
858
859	RTFILE RawFile;
860	int vrc = RTFileOpen(&RawFile, rawdisk.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
861	if (RT_FAILURE(vrc))
862	{
863	RTMsgError("Cannnot open the raw disk: %Rrc", vrc);
864	return vrc;
865	}
866
867	HOSTPARTITIONS partitions;
868	vrc = partRead(RawFile, &partitions);
869	/* Don't bail out on errors, print the table and return the result code. */
870
871	RTPrintf("Number Type StartCHS EndCHS Size (MiB) Start (Sect)\n");
872	for (unsigned i = 0; i < partitions.cPartitions; i++)
873	{
874	/* Don't show the extended partition, otherwise users might think they
875	* can add it to the list of partitions for raw partition access. */
876	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
877	continue;
878
879	RTPrintf("%-7u %#04x %-4u/%-3u/%-2u %-4u/%-3u/%-2u %10llu %10llu\n",
880	partitions.aPartitions[i].uIndex,
881	partitions.aPartitions[i].uType,
882	partitions.aPartitions[i].uStartCylinder,
883	partitions.aPartitions[i].uStartHead,
884	partitions.aPartitions[i].uStartSector,
885	partitions.aPartitions[i].uEndCylinder,
886	partitions.aPartitions[i].uEndHead,
887	partitions.aPartitions[i].uEndSector,
888	partitions.aPartitions[i].uSize / 2048,
889	partitions.aPartitions[i].uStart);
890	}
891
892	return vrc;
893	}
894
895	static PVBOXHDDRAWPARTDESC appendPartDesc(uint32_t pcPartDescs, PVBOXHDDRAWPARTDESC ppPartDescs)
896	{
897	(*pcPartDescs)++;
898	PVBOXHDDRAWPARTDESC p;
899	p = (PVBOXHDDRAWPARTDESC)RTMemRealloc(*ppPartDescs,
900	pcPartDescs sizeof(VBOXHDDRAWPARTDESC));
901	*ppPartDescs = p;
902	if (p)
903	{
904	p = p + *pcPartDescs - 1;
905	memset(p, '\0', sizeof(VBOXHDDRAWPARTDESC));
906	}
907
908	return p;
909	}
910
911	static int CmdCreateRawVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
912	{
913	HRESULT rc = S_OK;
914	Utf8Str filename;
915	const char *pszMBRFilename = NULL;
916	Utf8Str rawdisk;
917	const char *pszPartitions = NULL;
918	bool fRegister = false;
919	bool fRelative = false;
920
921	uint64_t cbSize = 0;
922	PVBOXHDD pDisk = NULL;
923	VBOXHDDRAW RawDescriptor;
924	PVDINTERFACE pVDIfs = NULL;
925
926	/* let's have a closer look at the arguments */
927	for (int i = 0; i < argc; i++)
928	{
929	if (strcmp(argv[i], "-filename") == 0)
930	{
931	if (argc <= i + 1)
932	{
933	return errorArgument("Missing argument to '%s'", argv[i]);
934	}
935	i++;
936	filename = argv[i];
937	}
938	else if (strcmp(argv[i], "-mbr") == 0)
939	{
940	if (argc <= i + 1)
941	{
942	return errorArgument("Missing argument to '%s'", argv[i]);
943	}
944	i++;
945	pszMBRFilename = argv[i];
946	}
947	else if (strcmp(argv[i], "-rawdisk") == 0)
948	{
949	if (argc <= i + 1)
950	{
951	return errorArgument("Missing argument to '%s'", argv[i]);
952	}
953	i++;
954	rawdisk = argv[i];
955	}
956	else if (strcmp(argv[i], "-partitions") == 0)
957	{
958	if (argc <= i + 1)
959	{
960	return errorArgument("Missing argument to '%s'", argv[i]);
961	}
962	i++;
963	pszPartitions = argv[i];
964	}
965	else if (strcmp(argv[i], "-register") == 0)
966	{
967	fRegister = true;
968	}
969	#ifdef RT_OS_LINUX
970	else if (strcmp(argv[i], "-relative") == 0)
971	{
972	fRelative = true;
973	}
974	#endif /* RT_OS_LINUX */
975	else
976	return errorSyntax(USAGE_CREATERAWVMDK, "Invalid parameter '%s'", argv[i]);
977	}
978
979	if (filename.isEmpty())
980	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -filename missing");
981	if (rawdisk.isEmpty())
982	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -rawdisk missing");
983	if (!pszPartitions && pszMBRFilename)
984	return errorSyntax(USAGE_CREATERAWVMDK, "The parameter -mbr is only valid when the parameter -partitions is also present");
985
986	#ifdef RT_OS_DARWIN
987	fRelative = true;
988	#endif /* RT_OS_DARWIN */
989	RTFILE RawFile;
990	int vrc = RTFileOpen(&RawFile, rawdisk.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
991	if (RT_FAILURE(vrc))
992	{
993	RTMsgError("Cannot open the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
994	goto out;
995	}
996
997	#ifdef RT_OS_WINDOWS
998	/* Windows NT has no IOCTL_DISK_GET_LENGTH_INFORMATION ioctl. This was
999	* added to Windows XP, so we have to use the available info from DriveGeo.
1000	* Note that we cannot simply use IOCTL_DISK_GET_DRIVE_GEOMETRY as it
1001	* yields a slightly different result than IOCTL_DISK_GET_LENGTH_INFO.
1002	* We call IOCTL_DISK_GET_DRIVE_GEOMETRY first as we need to check the media
1003	* type anyway, and if IOCTL_DISK_GET_LENGTH_INFORMATION is supported
1004	* we will later override cbSize.
1005	*/
1006	DISK_GEOMETRY DriveGeo;
1007	DWORD cbDriveGeo;
1008	if (DeviceIoControl((HANDLE)RawFile,
1009	IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
1010	&DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL))
1011	{
1012	if ( DriveGeo.MediaType == FixedMedia
1013	\|\| DriveGeo.MediaType == RemovableMedia)
1014	{
1015	cbSize = DriveGeo.Cylinders.QuadPart
1016	* DriveGeo.TracksPerCylinder
1017	* DriveGeo.SectorsPerTrack
1018	* DriveGeo.BytesPerSector;
1019	}
1020	else
1021	{
1022	RTMsgError("File '%s' is no fixed/removable medium device", rawdisk.c_str());
1023	vrc = VERR_INVALID_PARAMETER;
1024	goto out;
1025	}
1026
1027	GET_LENGTH_INFORMATION DiskLenInfo;
1028	DWORD junk;
1029	if (DeviceIoControl((HANDLE)RawFile,
1030	IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
1031	&DiskLenInfo, sizeof(DiskLenInfo), &junk, (LPOVERLAPPED)NULL))
1032	{
1033	/* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */
1034	cbSize = DiskLenInfo.Length.QuadPart;
1035	}
1036	}
1037	else
1038	{
1039	vrc = RTErrConvertFromWin32(GetLastError());
1040	RTMsgError("Cannot get the geometry of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1041	goto out;
1042	}
1043	#elif defined(RT_OS_LINUX)
1044	struct stat DevStat;
1045	if (!fstat(RawFile, &DevStat) && S_ISBLK(DevStat.st_mode))
1046	{
1047	#ifdef BLKGETSIZE64
1048	/* BLKGETSIZE64 is broken up to 2.4.17 and in many 2.5.x. In 2.6.0
1049	* it works without problems. */
1050	struct utsname utsname;
1051	if ( uname(&utsname) == 0
1052	&& ( (strncmp(utsname.release, "2.5.", 4) == 0 && atoi(&utsname.release[4]) >= 18)
1053	\|\| (strncmp(utsname.release, "2.", 2) == 0 && atoi(&utsname.release[2]) >= 6)))
1054	{
1055	uint64_t cbBlk;
1056	if (!ioctl(RawFile, BLKGETSIZE64, &cbBlk))
1057	cbSize = cbBlk;
1058	}
1059	#endif /* BLKGETSIZE64 */
1060	if (!cbSize)
1061	{
1062	long cBlocks;
1063	if (!ioctl(RawFile, BLKGETSIZE, &cBlocks))
1064	cbSize = (uint64_t)cBlocks << 9;
1065	else
1066	{
1067	vrc = RTErrConvertFromErrno(errno);
1068	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1069	goto out;
1070	}
1071	}
1072	}
1073	else
1074	{
1075	RTMsgError("File '%s' is no block device", rawdisk.c_str());
1076	vrc = VERR_INVALID_PARAMETER;
1077	goto out;
1078	}
1079	#elif defined(RT_OS_DARWIN)
1080	struct stat DevStat;
1081	if (!fstat(RawFile, &DevStat) && S_ISBLK(DevStat.st_mode))
1082	{
1083	uint64_t cBlocks;
1084	uint32_t cbBlock;
1085	if (!ioctl(RawFile, DKIOCGETBLOCKCOUNT, &cBlocks))
1086	{
1087	if (!ioctl(RawFile, DKIOCGETBLOCKSIZE, &cbBlock))
1088	cbSize = cBlocks * cbBlock;
1089	else
1090	{
1091	RTMsgError("Cannot get the block size for file '%s': %Rrc", rawdisk.c_str(), vrc);
1092	vrc = RTErrConvertFromErrno(errno);
1093	goto out;
1094	}
1095	}
1096	else
1097	{
1098	vrc = RTErrConvertFromErrno(errno);
1099	RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
1100	goto out;
1101	}
1102	}
1103	else
1104	{
1105	RTMsgError("File '%s' is no block device", rawdisk.c_str());
1106	vrc = VERR_INVALID_PARAMETER;
1107	goto out;
1108	}
1109	#elif defined(RT_OS_SOLARIS)
1110	struct stat DevStat;
1111	if (!fstat(RawFile, &DevStat) && ( S_ISBLK(DevStat.st_mode)
1112	\|\| S_ISCHR(DevStat.st_mode)))
1113	{
1114	struct dk_minfo mediainfo;
1115	if (!ioctl(RawFile, DKIOCGMEDIAINFO, &mediainfo))
1116	cbSize = mediainfo.dki_capacity * mediainfo.dki_lbsize;
1117	else
1118	{
1119	vrc = RTErrConvertFromErrno(errno);
1120	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1121	goto out;
1122	}
1123	}
1124	else
1125	{
1126	RTMsgError("File '%s' is no block or char device", rawdisk.c_str());
1127	vrc = VERR_INVALID_PARAMETER;
1128	goto out;
1129	}
1130	#elif defined(RT_OS_FREEBSD)
1131	struct stat DevStat;
1132	if (!fstat(RawFile, &DevStat) && S_ISCHR(DevStat.st_mode))
1133	{
1134	off_t cbMedia = 0;
1135	if (!ioctl(RawFile, DIOCGMEDIASIZE, &cbMedia))
1136	{
1137	cbSize = cbMedia;
1138	}
1139	else
1140	{
1141	vrc = RTErrConvertFromErrno(errno);
1142	RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
1143	goto out;
1144	}
1145	}
1146	else
1147	{
1148	RTMsgError("File '%s' is no character device", rawdisk.c_str());
1149	vrc = VERR_INVALID_PARAMETER;
1150	goto out;
1151	}
1152	#else /* all unrecognized OSes */
1153	/* Hopefully this works on all other hosts. If it doesn't, it'll just fail
1154	* creating the VMDK, so no real harm done. */
1155	vrc = RTFileGetSize(RawFile, &cbSize);
1156	if (RT_FAILURE(vrc))
1157	{
1158	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1159	goto out;
1160	}
1161	#endif
1162
1163	/* Check whether cbSize is actually sensible. */
1164	if (!cbSize \|\| cbSize % 512)
1165	{
1166	RTMsgError("Detected size of raw disk '%s' is %s, an invalid value", rawdisk.c_str(), cbSize);
1167	vrc = VERR_INVALID_PARAMETER;
1168	goto out;
1169	}
1170
1171	RawDescriptor.szSignature[0] = 'R';
1172	RawDescriptor.szSignature[1] = 'A';
1173	RawDescriptor.szSignature[2] = 'W';
1174	RawDescriptor.szSignature[3] = '\0';
1175	if (!pszPartitions)
1176	{
1177	RawDescriptor.fRawDisk = true;
1178	RawDescriptor.pszRawDisk = rawdisk.c_str();
1179	}
1180	else
1181	{
1182	RawDescriptor.fRawDisk = false;
1183	RawDescriptor.pszRawDisk = NULL;
1184	RawDescriptor.cPartDescs = 0;
1185	RawDescriptor.pPartDescs = NULL;
1186
1187	uint32_t uPartitions = 0;
1188
1189	const char *p = pszPartitions;
1190	char *pszNext;
1191	uint32_t u32;
1192	while (*p != '\0')
1193	{
1194	vrc = RTStrToUInt32Ex(p, &pszNext, 0, &u32);
1195	if (RT_FAILURE(vrc))
1196	{
1197	RTMsgError("Incorrect value in partitions parameter");
1198	goto out;
1199	}
1200	uPartitions \|= RT_BIT(u32);
1201	p = pszNext;
1202	if (*p == ',')
1203	p++;
1204	else if (*p != '\0')
1205	{
1206	RTMsgError("Incorrect separator in partitions parameter");
1207	vrc = VERR_INVALID_PARAMETER;
1208	goto out;
1209	}
1210	}
1211
1212	HOSTPARTITIONS partitions;
1213	vrc = partRead(RawFile, &partitions);
1214	if (RT_FAILURE(vrc))
1215	{
1216	RTMsgError("Cannot read the partition information from '%s'", rawdisk.c_str());
1217	goto out;
1218	}
1219
1220	for (unsigned i = 0; i < partitions.cPartitions; i++)
1221	{
1222	if ( uPartitions & RT_BIT(partitions.aPartitions[i].uIndex)
1223	&& PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1224	{
1225	/* Some ignorant user specified an extended partition.
1226	* Bad idea, as this would trigger an overlapping
1227	* partitions error later during VMDK creation. So warn
1228	* here and ignore what the user requested. */
1229	RTMsgWarning("It is not possible (and necessary) to explicitly give access to the "
1230	"extended partition %u. If required, enable access to all logical "
1231	"partitions inside this extended partition.",
1232	partitions.aPartitions[i].uIndex);
1233	uPartitions &= ~RT_BIT(partitions.aPartitions[i].uIndex);
1234	}
1235	}
1236
1237	for (unsigned i = 0; i < partitions.cPartitions; i++)
1238	{
1239	PVBOXHDDRAWPARTDESC pPartDesc = NULL;
1240
1241	/* first dump the MBR/EPT data area */
1242	if (partitions.aPartitions[i].cPartDataSectors)
1243	{
1244	pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs,
1245	&RawDescriptor.pPartDescs);
1246	if (!pPartDesc)
1247	{
1248	RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
1249	vrc = VERR_NO_MEMORY;
1250	goto out;
1251	}
1252
1253	/** @todo the clipping below isn't 100% accurate, as it should
1254	* actually clip to the track size. However that's easier said
1255	* than done as figuring out the track size is heuristics. In
1256	* any case the clipping is adjusted later after sorting, to
1257	* prevent overlapping data areas on the resulting image. */
1258	pPartDesc->cbData = RT_MIN(partitions.aPartitions[i].cPartDataSectors, 63) * 512;
1259	pPartDesc->uStart = partitions.aPartitions[i].uPartDataStart * 512;
1260	Assert(pPartDesc->cbData - (size_t)pPartDesc->cbData == 0);
1261	void *pPartData = RTMemAlloc((size_t)pPartDesc->cbData);
1262	if (!pPartData)
1263	{
1264	RTMsgError("Out of memory allocating the partition descriptor for '%s'", rawdisk.c_str());
1265	vrc = VERR_NO_MEMORY;
1266	goto out;
1267	}
1268	vrc = RTFileReadAt(RawFile, partitions.aPartitions[i].uPartDataStart * 512,
1269	pPartData, (size_t)pPartDesc->cbData, NULL);
1270	if (RT_FAILURE(vrc))
1271	{
1272	RTMsgError("Cannot read partition data from raw device '%s': %Rrc", rawdisk.c_str(), vrc);
1273	goto out;
1274	}
1275	/* Splice in the replacement MBR code if specified. */
1276	if ( partitions.aPartitions[i].uPartDataStart == 0
1277	&& pszMBRFilename)
1278	{
1279	RTFILE MBRFile;
1280	vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1281	if (RT_FAILURE(vrc))
1282	{
1283	RTMsgError("Cannot open replacement MBR file '%s' specified with -mbr: %Rrc", pszMBRFilename, vrc);
1284	goto out;
1285	}
1286	vrc = RTFileReadAt(MBRFile, 0, pPartData, 0x1be, NULL);
1287	RTFileClose(MBRFile);
1288	if (RT_FAILURE(vrc))
1289	{
1290	RTMsgError("Cannot read replacement MBR file '%s': %Rrc", pszMBRFilename, vrc);
1291	goto out;
1292	}
1293	}
1294	pPartDesc->pvPartitionData = pPartData;
1295	}
1296
1297	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1298	{
1299	/* Suppress exporting the actual extended partition. Only
1300	* logical partitions should be processed. However completely
1301	* ignoring it leads to leaving out the EBR data. */
1302	continue;
1303	}
1304
1305	/* set up values for non-relative device names */
1306	const char *pszRawName = rawdisk.c_str();
1307	uint64_t uStartOffset = partitions.aPartitions[i].uStart * 512;
1308
1309	pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs,
1310	&RawDescriptor.pPartDescs);
1311	if (!pPartDesc)
1312	{
1313	RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
1314	vrc = VERR_NO_MEMORY;
1315	goto out;
1316	}
1317
1318	if (uPartitions & RT_BIT(partitions.aPartitions[i].uIndex))
1319	{
1320	if (fRelative)
1321	{
1322	#ifdef RT_OS_LINUX
1323	/* Refer to the correct partition and use offset 0. */
1324	char *psz;
1325	vrc = RTStrAPrintf(&psz, "%s%u", rawdisk.c_str(),
1326	partitions.aPartitions[i].uIndex);
1327	if (RT_FAILURE(vrc))
1328	{
1329	RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
1330	partitions.aPartitions[i].uIndex, vrc);
1331	goto out;
1332	}
1333	pszRawName = psz;
1334	uStartOffset = 0;
1335	#elif defined(RT_OS_DARWIN)
1336	/* Refer to the correct partition and use offset 0. */
1337	char *psz;
1338	vrc = RTStrAPrintf(&psz, "%ss%u", rawdisk.c_str(),
1339	partitions.aPartitions[i].uIndex);
1340	if (RT_FAILURE(vrc))
1341	{
1342	RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
1343	partitions.aPartitions[i].uIndex, vrc);
1344	goto out;
1345	}
1346	pszRawName = psz;
1347	uStartOffset = 0;
1348	#else
1349	/** @todo not implemented for other hosts. Treat just like
1350	* not specified (this code is actually never reached). */
1351	#endif
1352	}
1353
1354	pPartDesc->pszRawDevice = pszRawName;
1355	pPartDesc->uStartOffset = uStartOffset;
1356	}
1357	else
1358	{
1359	pPartDesc->pszRawDevice = NULL;
1360	pPartDesc->uStartOffset = 0;
1361	}
1362
1363	pPartDesc->uStart = partitions.aPartitions[i].uStart * 512;
1364	pPartDesc->cbData = partitions.aPartitions[i].uSize * 512;
1365	}
1366
1367	/* Sort data areas in ascending order of start. */
1368	for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++)
1369	{
1370	unsigned uMinIdx = i;
1371	uint64_t uMinVal = RawDescriptor.pPartDescs[i].uStart;
1372	for (unsigned j = i + 1; j < RawDescriptor.cPartDescs; j++)
1373	{
1374	if (RawDescriptor.pPartDescs[j].uStart < uMinVal)
1375	{
1376	uMinIdx = j;
1377	uMinVal = RawDescriptor.pPartDescs[j].uStart;
1378	}
1379	}
1380	if (uMinIdx != i)
1381	{
1382	/* Swap entries at index i and uMinIdx. */
1383	VBOXHDDRAWPARTDESC tmp;
1384	memcpy(&tmp, &RawDescriptor.pPartDescs[i], sizeof(tmp));
1385	memcpy(&RawDescriptor.pPartDescs[i], &RawDescriptor.pPartDescs[uMinIdx], sizeof(tmp));
1386	memcpy(&RawDescriptor.pPartDescs[uMinIdx], &tmp, sizeof(tmp));
1387	}
1388	}
1389
1390	/* Have a second go at MBR/EPT area clipping. Now that the data areas
1391	* are sorted this is much easier to get 100% right. */
1392	for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++)
1393	{
1394	if (RawDescriptor.pPartDescs[i].pvPartitionData)
1395	{
1396	RawDescriptor.pPartDescs[i].cbData = RT_MIN(RawDescriptor.pPartDescs[i+1].uStart - RawDescriptor.pPartDescs[i].uStart, RawDescriptor.pPartDescs[i].cbData);
1397	if (!RawDescriptor.pPartDescs[i].cbData)
1398	{
1399	RTMsgError("MBR/EPT overlaps with data area");
1400	vrc = VERR_INVALID_PARAMETER;
1401	goto out;
1402	}
1403	}
1404	}
1405	}
1406
1407	RTFileClose(RawFile);
1408
1409	#ifdef DEBUG_klaus
1410	RTPrintf("# start length startoffset partdataptr device\n");
1411	for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++)
1412	{
1413	RTPrintf("%2u %14RU64 %14RU64 %14RU64 %#18p %s\n", i,
1414	RawDescriptor.pPartDescs[i].uStart,
1415	RawDescriptor.pPartDescs[i].cbData,
1416	RawDescriptor.pPartDescs[i].uStartOffset,
1417	RawDescriptor.pPartDescs[i].pvPartitionData,
1418	RawDescriptor.pPartDescs[i].pszRawDevice);
1419	}
1420	#endif
1421
1422	VDINTERFACE vdInterfaceError;
1423	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1424	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1425	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1426	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1427	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
1428
1429	vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1430	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1431	AssertRC(vrc);
1432
1433	vrc = VDCreate(pVDIfs, &pDisk);
1434	if (RT_FAILURE(vrc))
1435	{
1436	RTMsgError("Cannot create the virtual disk container: %Rrc", vrc);
1437	goto out;
1438	}
1439
1440	Assert(RT_MIN(cbSize / 512 / 16 / 63, 16383) -
1441	(unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383) == 0);
1442	VDGEOMETRY PCHS, LCHS;
1443	PCHS.cCylinders = (unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383);
1444	PCHS.cHeads = 16;
1445	PCHS.cSectors = 63;
1446	LCHS.cCylinders = 0;
1447	LCHS.cHeads = 0;
1448	LCHS.cSectors = 0;
1449	vrc = VDCreateBase(pDisk, "VMDK", filename.c_str(), cbSize,
1450	VD_IMAGE_FLAGS_FIXED \| VD_VMDK_IMAGE_FLAGS_RAWDISK,
1451	(char *)&RawDescriptor, &PCHS, &LCHS, NULL,
1452	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1453	if (RT_FAILURE(vrc))
1454	{
1455	RTMsgError("Cannot create the raw disk VMDK: %Rrc", vrc);
1456	goto out;
1457	}
1458	RTPrintf("RAW host disk access VMDK file %s created successfully.\n", filename.c_str());
1459
1460	VDCloseAll(pDisk);
1461
1462	/* Clean up allocated memory etc. */
1463	if (pszPartitions)
1464	{
1465	for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++)
1466	{
1467	/* Free memory allocated for relative device name. */
1468	if (fRelative && RawDescriptor.pPartDescs[i].pszRawDevice)
1469	RTStrFree((char )(void )RawDescriptor.pPartDescs[i].pszRawDevice);
1470	if (RawDescriptor.pPartDescs[i].pvPartitionData)
1471	RTMemFree((void *)RawDescriptor.pPartDescs[i].pvPartitionData);
1472	}
1473	if (RawDescriptor.pPartDescs)
1474	RTMemFree(RawDescriptor.pPartDescs);
1475	}
1476
1477	if (fRegister)
1478	{
1479	ComPtr<IMedium> hardDisk;
1480	CHECK_ERROR(aVirtualBox, OpenMedium(Bstr(filename).raw(),
1481	DeviceType_HardDisk,
1482	AccessMode_ReadWrite,
1483	hardDisk.asOutParam()));
1484	}
1485
1486	return SUCCEEDED(rc) ? 0 : 1;
1487
1488	out:
1489	RTMsgError("The raw disk vmdk file was not created");
1490	return RT_SUCCESS(vrc) ? 0 : 1;
1491	}
1492
1493	static int CmdRenameVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1494	{
1495	Utf8Str src;
1496	Utf8Str dst;
1497	/* Parse the arguments. */
1498	for (int i = 0; i < argc; i++)
1499	{
1500	if (strcmp(argv[i], "-from") == 0)
1501	{
1502	if (argc <= i + 1)
1503	{
1504	return errorArgument("Missing argument to '%s'", argv[i]);
1505	}
1506	i++;
1507	src = argv[i];
1508	}
1509	else if (strcmp(argv[i], "-to") == 0)
1510	{
1511	if (argc <= i + 1)
1512	{
1513	return errorArgument("Missing argument to '%s'", argv[i]);
1514	}
1515	i++;
1516	dst = argv[i];
1517	}
1518	else
1519	{
1520	return errorSyntax(USAGE_RENAMEVMDK, "Invalid parameter '%s'", argv[i]);
1521	}
1522	}
1523
1524	if (src.isEmpty())
1525	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -from missing");
1526	if (dst.isEmpty())
1527	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -to missing");
1528
1529	PVBOXHDD pDisk = NULL;
1530
1531	PVDINTERFACE pVDIfs = NULL;
1532	VDINTERFACE vdInterfaceError;
1533	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1534	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1535	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1536	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1537	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
1538
1539	int vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1540	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1541	AssertRC(vrc);
1542
1543	vrc = VDCreate(pVDIfs, &pDisk);
1544	if (RT_FAILURE(vrc))
1545	{
1546	RTMsgError("Cannot create the virtual disk container: %Rrc", vrc);
1547	return vrc;
1548	}
1549	else
1550	{
1551	vrc = VDOpen(pDisk, "VMDK", src.c_str(), VD_OPEN_FLAGS_NORMAL, NULL);
1552	if (RT_FAILURE(vrc))
1553	{
1554	RTMsgError("Cannot create the source image: %Rrc", vrc);
1555	}
1556	else
1557	{
1558	vrc = VDCopy(pDisk, 0, pDisk, "VMDK", dst.c_str(), true, 0,
1559	VD_IMAGE_FLAGS_NONE, NULL, VD_OPEN_FLAGS_NORMAL,
1560	NULL, NULL, NULL);
1561	if (RT_FAILURE(vrc))
1562	{
1563	RTMsgError("Cannot rename the image: %Rrc", vrc);
1564	}
1565	}
1566	}
1567	VDCloseAll(pDisk);
1568	return vrc;
1569	}
1570
1571	static int CmdConvertToRaw(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1572	{
1573	Utf8Str srcformat;
1574	Utf8Str src;
1575	Utf8Str dst;
1576	bool fWriteToStdOut = false;
1577
1578	/* Parse the arguments. */
1579	for (int i = 0; i < argc; i++)
1580	{
1581	if (strcmp(argv[i], "-format") == 0)
1582	{
1583	if (argc <= i + 1)
1584	{
1585	return errorArgument("Missing argument to '%s'", argv[i]);
1586	}
1587	i++;
1588	srcformat = argv[i];
1589	}
1590	else if (src.isEmpty())
1591	{
1592	src = argv[i];
1593	}
1594	else if (dst.isEmpty())
1595	{
1596	dst = argv[i];
1597	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
1598	if (!strcmp(argv[i], "stdout"))
1599	fWriteToStdOut = true;
1600	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
1601	}
1602	else
1603	{
1604	return errorSyntax(USAGE_CONVERTTORAW, "Invalid parameter '%s'", argv[i]);
1605	}
1606	}
1607
1608	if (src.isEmpty())
1609	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory filename parameter missing");
1610	if (dst.isEmpty())
1611	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory outputfile parameter missing");
1612
1613	PVBOXHDD pDisk = NULL;
1614
1615	PVDINTERFACE pVDIfs = NULL;
1616	VDINTERFACE vdInterfaceError;
1617	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1618	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1619	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1620	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1621	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
1622
1623	int vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1624	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1625	AssertRC(vrc);
1626
1627	vrc = VDCreate(pVDIfs, &pDisk);
1628	if (RT_FAILURE(vrc))
1629	{
1630	RTMsgError("Cannot create the virtual disk container: %Rrc", vrc);
1631	return 1;
1632	}
1633
1634	/* Open raw output file. */
1635	RTFILE outFile;
1636	vrc = VINF_SUCCESS;
1637	if (fWriteToStdOut)
1638	outFile = 1;
1639	else
1640	vrc = RTFileOpen(&outFile, dst.c_str(), RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_ALL);
1641	if (RT_FAILURE(vrc))
1642	{
1643	VDCloseAll(pDisk);
1644	RTMsgError("Cannot create destination file \"%s\": %Rrc", dst.c_str(), vrc);
1645	return 1;
1646	}
1647
1648	if (srcformat.isEmpty())
1649	{
1650	char *pszFormat = NULL;
1651	vrc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
1652	src.c_str(), &pszFormat);
1653	if (RT_FAILURE(vrc))
1654	{
1655	VDCloseAll(pDisk);
1656	if (!fWriteToStdOut)
1657	{
1658	RTFileClose(outFile);
1659	RTFileDelete(dst.c_str());
1660	}
1661	RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
1662	return 1;
1663	}
1664	srcformat = pszFormat;
1665	RTStrFree(pszFormat);
1666	}
1667	vrc = VDOpen(pDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL);
1668	if (RT_FAILURE(vrc))
1669	{
1670	VDCloseAll(pDisk);
1671	if (!fWriteToStdOut)
1672	{
1673	RTFileClose(outFile);
1674	RTFileDelete(dst.c_str());
1675	}
1676	RTMsgError("Cannot open the source image: %Rrc", vrc);
1677	return 1;
1678	}
1679
1680	uint64_t cbSize = VDGetSize(pDisk, VD_LAST_IMAGE);
1681	uint64_t offFile = 0;
1682	#define RAW_BUFFER_SIZE _128K
1683	size_t cbBuf = RAW_BUFFER_SIZE;
1684	void *pvBuf = RTMemAlloc(cbBuf);
1685	if (pvBuf)
1686	{
1687	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
1688	while (offFile < cbSize)
1689	{
1690	size_t cb = (size_t)RT_MIN(cbSize - offFile, cbBuf);
1691	vrc = VDRead(pDisk, offFile, pvBuf, cb);
1692	if (RT_FAILURE(vrc))
1693	break;
1694	vrc = RTFileWrite(outFile, pvBuf, cb, NULL);
1695	if (RT_FAILURE(vrc))
1696	break;
1697	offFile += cb;
1698	}
1699	if (RT_FAILURE(vrc))
1700	{
1701	VDCloseAll(pDisk);
1702	if (!fWriteToStdOut)
1703	{
1704	RTFileClose(outFile);
1705	RTFileDelete(dst.c_str());
1706	}
1707	RTMsgError("Cannot copy image data: %Rrc", vrc);
1708	return 1;
1709	}
1710	}
1711	else
1712	{
1713	vrc = VERR_NO_MEMORY;
1714	VDCloseAll(pDisk);
1715	if (!fWriteToStdOut)
1716	{
1717	RTFileClose(outFile);
1718	RTFileDelete(dst.c_str());
1719	}
1720	RTMsgError("Out of memory allocating read buffer");
1721	return 1;
1722	}
1723
1724	if (!fWriteToStdOut)
1725	RTFileClose(outFile);
1726	VDCloseAll(pDisk);
1727	return 0;
1728	}
1729
1730	static int CmdConvertHardDisk(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1731	{
1732	Utf8Str srcformat;
1733	Utf8Str dstformat;
1734	Utf8Str src;
1735	Utf8Str dst;
1736	int vrc;
1737	PVBOXHDD pSrcDisk = NULL;
1738	PVBOXHDD pDstDisk = NULL;
1739
1740	/* Parse the arguments. */
1741	for (int i = 0; i < argc; i++)
1742	{
1743	if (strcmp(argv[i], "-srcformat") == 0)
1744	{
1745	if (argc <= i + 1)
1746	{
1747	return errorArgument("Missing argument to '%s'", argv[i]);
1748	}
1749	i++;
1750	srcformat = argv[i];
1751	}
1752	else if (strcmp(argv[i], "-dstformat") == 0)
1753	{
1754	if (argc <= i + 1)
1755	{
1756	return errorArgument("Missing argument to '%s'", argv[i]);
1757	}
1758	i++;
1759	dstformat = argv[i];
1760	}
1761	else if (src.isEmpty())
1762	{
1763	src = argv[i];
1764	}
1765	else if (dst.isEmpty())
1766	{
1767	dst = argv[i];
1768	}
1769	else
1770	{
1771	return errorSyntax(USAGE_CONVERTHD, "Invalid parameter '%s'", argv[i]);
1772	}
1773	}
1774
1775	if (src.isEmpty())
1776	return errorSyntax(USAGE_CONVERTHD, "Mandatory input image parameter missing");
1777	if (dst.isEmpty())
1778	return errorSyntax(USAGE_CONVERTHD, "Mandatory output image parameter missing");
1779
1780
1781	PVDINTERFACE pVDIfs = NULL;
1782	VDINTERFACE vdInterfaceError;
1783	VDINTERFACEERROR vdInterfaceErrorCallbacks;
1784	vdInterfaceErrorCallbacks.cbSize = sizeof(VDINTERFACEERROR);
1785	vdInterfaceErrorCallbacks.enmInterface = VDINTERFACETYPE_ERROR;
1786	vdInterfaceErrorCallbacks.pfnError = handleVDError;
1787	vdInterfaceErrorCallbacks.pfnMessage = handleVDMessage;
1788
1789	vrc = VDInterfaceAdd(&vdInterfaceError, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1790	&vdInterfaceErrorCallbacks, NULL, &pVDIfs);
1791	AssertRC(vrc);
1792
1793	do
1794	{
1795	/* Try to determine input image format */
1796	if (srcformat.isEmpty())
1797	{
1798	char *pszFormat = NULL;
1799	vrc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
1800	src.c_str(), &pszFormat);
1801	if (RT_FAILURE(vrc))
1802	{
1803	RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
1804	break;
1805	}
1806	srcformat = pszFormat;
1807	RTStrFree(pszFormat);
1808	}
1809
1810	vrc = VDCreate(pVDIfs, &pSrcDisk);
1811	if (RT_FAILURE(vrc))
1812	{
1813	RTMsgError("Cannot create the source virtual disk container: %Rrc", vrc);
1814	break;
1815	}
1816
1817	/* Open the input image */
1818	vrc = VDOpen(pSrcDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL);
1819	if (RT_FAILURE(vrc))
1820	{
1821	RTMsgError("Cannot open the source image: %Rrc", vrc);
1822	break;
1823	}
1824
1825	/* Output format defaults to VDI */
1826	if (dstformat.isEmpty())
1827	dstformat = "VDI";
1828
1829	vrc = VDCreate(pVDIfs, &pDstDisk);
1830	if (RT_FAILURE(vrc))
1831	{
1832	RTMsgError("Cannot create the destination virtual disk container: %Rrc", vrc);
1833	break;
1834	}
1835
1836	uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
1837	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
1838
1839	/* Create the output image */
1840	vrc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, dstformat.c_str(),
1841	dst.c_str(), false, 0, VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED,
1842	NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL, NULL);
1843	if (RT_FAILURE(vrc))
1844	{
1845	RTMsgError("Cannot copy the image: %Rrc", vrc);
1846	break;
1847	}
1848	}
1849	while (0);
1850	if (pDstDisk)
1851	VDCloseAll(pDstDisk);
1852	if (pSrcDisk)
1853	VDCloseAll(pSrcDisk);
1854
1855	return RT_SUCCESS(vrc) ? 0 : 1;
1856	}
1857
1858	/**
1859	* Unloads the neccessary driver.
1860	*
1861	* @returns VBox status code
1862	*/
1863	int CmdModUninstall(void)
1864	{
1865	int rc;
1866
1867	rc = SUPR3Uninstall();
1868	if (RT_SUCCESS(rc))
1869	return 0;
1870	if (rc == VERR_NOT_IMPLEMENTED)
1871	return 0;
1872	return E_FAIL;
1873	}
1874
1875	/**
1876	* Loads the neccessary driver.
1877	*
1878	* @returns VBox status code
1879	*/
1880	int CmdModInstall(void)
1881	{
1882	int rc;
1883
1884	rc = SUPR3Install();
1885	if (RT_SUCCESS(rc))
1886	return 0;
1887	if (rc == VERR_NOT_IMPLEMENTED)
1888	return 0;
1889	return E_FAIL;
1890	}
1891
1892	int CmdDebugLog(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1893	{
1894	/*
1895	* The first parameter is the name or UUID of a VM with a direct session
1896	* that we wish to open.
1897	*/
1898	if (argc < 1)
1899	return errorSyntax(USAGE_DEBUGLOG, "Missing VM name/UUID");
1900
1901	ComPtr<IMachine> ptrMachine;
1902	HRESULT rc = aVirtualBox->GetMachine(Bstr(argv[0]).raw(),
1903	ptrMachine.asOutParam());
1904	if (FAILED(rc) \|\| ptrMachine.isNull())
1905	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
1906	ptrMachine.asOutParam()), 1);
1907
1908	CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), 1);
1909
1910	/*
1911	* Get the debugger interface.
1912	*/
1913	ComPtr<IConsole> ptrConsole;
1914	CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), 1);
1915
1916	ComPtr<IMachineDebugger> ptrDebugger;
1917	CHECK_ERROR_RET(ptrConsole, COMGETTER(Debugger)(ptrDebugger.asOutParam()), 1);
1918
1919	/*
1920	* Parse the command.
1921	*/
1922	bool fEnablePresent = false;
1923	bool fEnable = false;
1924	bool fFlagsPresent = false;
1925	iprt::MiniString strFlags;
1926	bool fGroupsPresent = false;
1927	iprt::MiniString strGroups;
1928	bool fDestsPresent = false;
1929	iprt::MiniString strDests;
1930
1931	static const RTGETOPTDEF s_aOptions[] =
1932	{
1933	{ "--disable", 'E', RTGETOPT_REQ_NOTHING },
1934	{ "--enable", 'e', RTGETOPT_REQ_NOTHING },
1935	{ "--flags", 'f', RTGETOPT_REQ_STRING },
1936	{ "--groups", 'g', RTGETOPT_REQ_STRING },
1937	{ "--destinations", 'd', RTGETOPT_REQ_STRING }
1938	};
1939
1940	int ch;
1941	RTGETOPTUNION ValueUnion;
1942	RTGETOPTSTATE GetState;
1943	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
1944	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1945	{
1946	switch (ch)
1947	{
1948	case 'e':
1949	fEnablePresent = true;
1950	fEnable = true;
1951	break;
1952
1953	case 'E':
1954	fEnablePresent = true;
1955	fEnable = false;
1956	break;
1957
1958	case 'f':
1959	fFlagsPresent = true;
1960	if (*ValueUnion.psz)
1961	{
1962	if (strFlags.isNotEmpty())
1963	strFlags.append(' ');
1964	strFlags.append(ValueUnion.psz);
1965	}
1966	break;
1967
1968	case 'g':
1969	fGroupsPresent = true;
1970	if (*ValueUnion.psz)
1971	{
1972	if (strGroups.isNotEmpty())
1973	strGroups.append(' ');
1974	strGroups.append(ValueUnion.psz);
1975	}
1976	break;
1977
1978	case 'd':
1979	fDestsPresent = true;
1980	if (*ValueUnion.psz)
1981	{
1982	if (strDests.isNotEmpty())
1983	strDests.append(' ');
1984	strDests.append(ValueUnion.psz);
1985	}
1986	break;
1987
1988	default:
1989	return errorGetOpt(USAGE_DEBUGLOG , ch, &ValueUnion);
1990	}
1991	}
1992
1993	/*
1994	* Do the job.
1995	*/
1996	if (fEnablePresent && !fEnable)
1997	CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(FALSE), 1);
1998
1999	/** @todo flags, groups destination. */
2000	if (fFlagsPresent \|\| fGroupsPresent \|\| fDestsPresent)
2001	RTMsgWarning("One or more of the requested features are not implemented! Feel free to do this.");
2002
2003	if (fEnablePresent && fEnable)
2004	CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(TRUE), 1);
2005	return 0;
2006	}
2007
2008	/**
2009	* Wrapper for handling internal commands
2010	*/
2011	int handleInternalCommands(HandlerArg *a)
2012	{
2013	g_fInternalMode = true;
2014
2015	/* at least a command is required */
2016	if (a->argc < 1)
2017	return errorSyntax(USAGE_ALL, "Command missing");
2018
2019	/*
2020	* The 'string switch' on command name.
2021	*/
2022	const char *pszCmd = a->argv[0];
2023	if (!strcmp(pszCmd, "loadsyms"))
2024	return CmdLoadSyms(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2025	//if (!strcmp(pszCmd, "unloadsyms"))
2026	// return CmdUnloadSyms(argc - 1 , &a->argv[1]);
2027	if (!strcmp(pszCmd, "sethduuid") \|\| !strcmp(pszCmd, "sethdparentuuid"))
2028	return CmdSetHDUUID(a->argc, &a->argv[0], a->virtualBox, a->session);
2029	if (!strcmp(pszCmd, "dumphdinfo"))
2030	return CmdDumpHDInfo(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2031	if (!strcmp(pszCmd, "listpartitions"))
2032	return CmdListPartitions(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2033	if (!strcmp(pszCmd, "createrawvmdk"))
2034	return CmdCreateRawVMDK(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2035	if (!strcmp(pszCmd, "renamevmdk"))
2036	return CmdRenameVMDK(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2037	if (!strcmp(pszCmd, "converttoraw"))
2038	return CmdConvertToRaw(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2039	if (!strcmp(pszCmd, "converthd"))
2040	return CmdConvertHardDisk(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2041	if (!strcmp(pszCmd, "modinstall"))
2042	return CmdModInstall();
2043	if (!strcmp(pszCmd, "moduninstall"))
2044	return CmdModUninstall();
2045	if (!strcmp(pszCmd, "debuglog"))
2046	return CmdDebugLog(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2047
2048	/* default: */
2049	return errorSyntax(USAGE_ALL, "Invalid command '%s'", a->argv[0]);
2050	}
2051

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp@ 33082

Download in other formats: