VBoxInternalManage.cpp@ 33540

Last change on this file since 33540 was 33540, checked in by vboxsync, 14 years ago
*: spelling fixes, thanks Timeless!
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 68.8 KB

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

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

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

Download in other formats: