VBoxInternalManage.cpp@ 35801

Last change on this file since 35801 was 35238, checked in by vboxsync, 14 years ago
Frontends/VBoxManage: makes no sense to register a raw disk/partition VMDK immediately with the new registry logic
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.3 KB

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

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

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

Download in other formats: