VBoxInternalManage.cpp@ 57671

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

Line
1	/* $Id: VBoxInternalManage.cpp 57428 2015-08-18 13:24:49Z 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-2015 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	/** partition number */
95	unsigned uIndex;
96	/** partition number (internal only, windows specific numbering) */
97	unsigned uIndexWin;
98	/** partition type */
99	unsigned uType;
100	/** CHS/cylinder of the first sector */
101	unsigned uStartCylinder;
102	/** CHS/head of the first sector */
103	unsigned uStartHead;
104	/** CHS/head of the first sector */
105	unsigned uStartSector;
106	/** CHS/cylinder of the last sector */
107	unsigned uEndCylinder;
108	/** CHS/head of the last sector */
109	unsigned uEndHead;
110	/** CHS/sector of the last sector */
111	unsigned uEndSector;
112	/** start sector of this partition relative to the beginning of the hard
113	* disk or relative to the beginning of the extended partition table */
114	uint64_t uStart;
115	/** numer of sectors of the partition */
116	uint64_t uSize;
117	/** start sector of this partition _table_ */
118	uint64_t uPartDataStart;
119	/** numer of sectors of this partition _table_ */
120	uint64_t cPartDataSectors;
121	} HOSTPARTITION, *PHOSTPARTITION;
122
123	typedef struct HOSTPARTITIONS
124	{
125	/** partitioning type - MBR or GPT */
126	VBOXHDDPARTTYPE uPartitioningType;
127	unsigned cPartitions;
128	HOSTPARTITION aPartitions[HOSTPARTITION_MAX];
129	} HOSTPARTITIONS, *PHOSTPARTITIONS;
130
131	/** flag whether we're in internal mode */
132	bool g_fInternalMode;
133
134	/**
135	* Print the usage info.
136	*/
137	void printUsageInternal(USAGECATEGORY u64Cmd, PRTSTREAM pStrm)
138	{
139	RTStrmPrintf(pStrm,
140	"Usage: VBoxManage internalcommands <command> [command arguments]\n"
141	"\n"
142	"Commands:\n"
143	"\n"
144	"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s"
145	"WARNING: This is a development tool and shall only be used to analyse\n"
146	" problems. It is completely unsupported and will change in\n"
147	" incompatible ways without warning.\n",
148
149	(u64Cmd & USAGE_LOADMAP)
150	? " loadmap <vmname\|uuid> <symfile> <address> [module] [subtrahend] [segment]\n"
151	" This will instruct DBGF to load the given map file\n"
152	" during initialization. (See also loadmap in the debugger.)\n"
153	"\n"
154	: "",
155	(u64Cmd & USAGE_LOADSYMS)
156	? " loadsyms <vmname\|uuid> <symfile> [delta] [module] [module address]\n"
157	" This will instruct DBGF to load the given symbol file\n"
158	" during initialization.\n"
159	"\n"
160	: "",
161	(u64Cmd & USAGE_SETHDUUID)
162	? " sethduuid <filepath> [<uuid>]\n"
163	" Assigns a new UUID to the given image file. This way, multiple copies\n"
164	" of a container can be registered.\n"
165	"\n"
166	: "",
167	(u64Cmd & USAGE_SETHDPARENTUUID)
168	? " sethdparentuuid <filepath> <uuid>\n"
169	" Assigns a new parent UUID to the given image file.\n"
170	"\n"
171	: "",
172	(u64Cmd & USAGE_DUMPHDINFO)
173	? " dumphdinfo <filepath>\n"
174	" Prints information about the image at the given location.\n"
175	"\n"
176	: "",
177	(u64Cmd & USAGE_LISTPARTITIONS)
178	? " listpartitions -rawdisk <diskname>\n"
179	" Lists all partitions on <diskname>.\n"
180	"\n"
181	: "",
182	(u64Cmd & USAGE_CREATERAWVMDK)
183	? " createrawvmdk -filename <filename> -rawdisk <diskname>\n"
184	" [-partitions <list of partition numbers> [-mbr <filename>] ]\n"
185	" [-relative]\n"
186	" Creates a new VMDK image which gives access to an entite host disk (if\n"
187	" the parameter -partitions is not specified) or some partitions of a\n"
188	" host disk. If access to individual partitions is granted, then the\n"
189	" parameter -mbr can be used to specify an alternative MBR to be used\n"
190	" (the partitioning information in the MBR file is ignored).\n"
191	" The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n"
192	" \\\\.\\PhysicalDrive0).\n"
193	" On Linux or FreeBSD host the parameter -relative causes a VMDK file to\n"
194	" be created which refers to individual partitions instead to the entire\n"
195	" disk.\n"
196	" The necessary partition numbers can be queried with\n"
197	" VBoxManage internalcommands listpartitions\n"
198	"\n"
199	: "",
200	(u64Cmd & USAGE_RENAMEVMDK)
201	? " renamevmdk -from <filename> -to <filename>\n"
202	" Renames an existing VMDK image, including the base file and all its extents.\n"
203	"\n"
204	: "",
205	(u64Cmd & USAGE_CONVERTTORAW)
206	? " converttoraw [-format <fileformat>] <filename> <outputfile>"
207	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
208	"\|stdout"
209	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
210	"\n"
211	" Convert image to raw, writing to file"
212	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
213	" or stdout"
214	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
215	".\n"
216	"\n"
217	: "",
218	(u64Cmd & USAGE_CONVERTHD)
219	? " converthd [-srcformat VDI\|VMDK\|VHD\|RAW]\n"
220	" [-dstformat VDI\|VMDK\|VHD\|RAW]\n"
221	" <inputfile> <outputfile>\n"
222	" converts hard disk images between formats\n"
223	"\n"
224	: "",
225	(u64Cmd & USAGE_REPAIRHD)
226	? " repairhd [-dry-run]\n"
227	" [-format VDI\|VMDK\|VHD\|...]\n"
228	" <filename>\n"
229	" Tries to repair corrupted disk images\n"
230	"\n"
231	: "",
232	#ifdef RT_OS_WINDOWS
233	(u64Cmd & USAGE_MODINSTALL)
234	? " modinstall\n"
235	" Installs the necessary driver for the host OS\n"
236	"\n"
237	: "",
238	(u64Cmd & USAGE_MODUNINSTALL)
239	? " moduninstall\n"
240	" Deinstalls the driver\n"
241	"\n"
242	: "",
243	#else
244	"",
245	"",
246	#endif
247	(u64Cmd & USAGE_DEBUGLOG)
248	? " debuglog <vmname\|uuid> [--enable\|--disable] [--flags todo]\n"
249	" [--groups todo] [--destinations todo]\n"
250	" Controls debug logging.\n"
251	"\n"
252	: "",
253	(u64Cmd & USAGE_PASSWORDHASH)
254	? " passwordhash <passsword>\n"
255	" Generates a password hash.\n"
256	"\n"
257	: "",
258	(u64Cmd & USAGE_GUESTSTATS)
259	? " gueststats <vmname\|uuid> [--interval <seconds>]\n"
260	" Obtains and prints internal guest statistics.\n"
261	" Sets the update interval if specified.\n"
262	"\n"
263	: ""
264	);
265	}
266
267	/** @todo this is no longer necessary, we can enumerate extra data */
268	/**
269	* Finds a new unique key name.
270	*
271	* I don't think this is 100% race condition proof, but we assumes
272	* the user is not trying to push this point.
273	*
274	* @returns Result from the insert.
275	* @param pMachine The Machine object.
276	* @param pszKeyBase The base key.
277	* @param rKey Reference to the string object in which we will return the key.
278	*/
279	static HRESULT NewUniqueKey(ComPtr<IMachine> pMachine, const char *pszKeyBase, Utf8Str &rKey)
280	{
281	Bstr KeyBase(pszKeyBase);
282	Bstr Keys;
283	HRESULT hrc = pMachine->GetExtraData(KeyBase.raw(), Keys.asOutParam());
284	if (FAILED(hrc))
285	return hrc;
286
287	/* if there are no keys, it's simple. */
288	if (Keys.isEmpty())
289	{
290	rKey = "1";
291	return pMachine->SetExtraData(KeyBase.raw(), Bstr(rKey).raw());
292	}
293
294	/* find a unique number - brute force rulez. */
295	Utf8Str KeysUtf8(Keys);
296	const char *pszKeys = RTStrStripL(KeysUtf8.c_str());
297	for (unsigned i = 1; i < 1000000; i++)
298	{
299	char szKey[32];
300	size_t cchKey = RTStrPrintf(szKey, sizeof(szKey), "%#x", i);
301	const char *psz = strstr(pszKeys, szKey);
302	while (psz)
303	{
304	if ( ( psz == pszKeys
305	\|\| psz[-1] == ' ')
306	&& ( psz[cchKey] == ' '
307	\|\| !psz[cchKey])
308	)
309	break;
310	psz = strstr(psz + cchKey, szKey);
311	}
312	if (!psz)
313	{
314	rKey = szKey;
315	Utf8StrFmt NewKeysUtf8("%s %s", pszKeys, szKey);
316	return pMachine->SetExtraData(KeyBase.raw(),
317	Bstr(NewKeysUtf8).raw());
318	}
319	}
320	RTMsgError("Cannot find unique key for '%s'!", pszKeyBase);
321	return E_FAIL;
322	}
323
324
325	#if 0
326	/**
327	* Remove a key.
328	*
329	* I don't think this isn't 100% race condition proof, but we assumes
330	* the user is not trying to push this point.
331	*
332	* @returns Result from the insert.
333	* @param pMachine The machine object.
334	* @param pszKeyBase The base key.
335	* @param pszKey The key to remove.
336	*/
337	static HRESULT RemoveKey(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey)
338	{
339	Bstr Keys;
340	HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam());
341	if (FAILED(hrc))
342	return hrc;
343
344	/* if there are no keys, it's simple. */
345	if (Keys.isEmpty())
346	return S_OK;
347
348	char *pszKeys;
349	int rc = RTUtf16ToUtf8(Keys.raw(), &pszKeys);
350	if (RT_SUCCESS(rc))
351	{
352	/* locate it */
353	size_t cchKey = strlen(pszKey);
354	char *psz = strstr(pszKeys, pszKey);
355	while (psz)
356	{
357	if ( ( psz == pszKeys
358	\|\| psz[-1] == ' ')
359	&& ( psz[cchKey] == ' '
360	\|\| !psz[cchKey])
361	)
362	break;
363	psz = strstr(psz + cchKey, pszKey);
364	}
365	if (psz)
366	{
367	/* remove it */
368	char *pszNext = RTStrStripL(psz + cchKey);
369	if (*pszNext)
370	memmove(psz, pszNext, strlen(pszNext) + 1);
371	else
372	*psz = '\0';
373	psz = RTStrStrip(pszKeys);
374
375	/* update */
376	hrc = pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(psz));
377	}
378
379	RTStrFree(pszKeys);
380	return hrc;
381	}
382	else
383	RTMsgError("Failed to delete key '%s' from '%s', string conversion error %Rrc!",
384	pszKey, pszKeyBase, rc);
385
386	return E_FAIL;
387	}
388	#endif
389
390
391	/**
392	* Sets a key value, does necessary error bitching.
393	*
394	* @returns COM status code.
395	* @param pMachine The Machine object.
396	* @param pszKeyBase The key base.
397	* @param pszKey The key.
398	* @param pszAttribute The attribute name.
399	* @param pszValue The string value.
400	*/
401	static HRESULT SetString(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char pszAttribute, const char pszValue)
402	{
403	HRESULT hrc = pMachine->SetExtraData(BstrFmt("%s/%s/%s", pszKeyBase,
404	pszKey, pszAttribute).raw(),
405	Bstr(pszValue).raw());
406	if (FAILED(hrc))
407	RTMsgError("Failed to set '%s/%s/%s' to '%s'! hrc=%#x",
408	pszKeyBase, pszKey, pszAttribute, pszValue, hrc);
409	return hrc;
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 u64Value The value.
422	*/
423	static HRESULT SetUInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, uint64_t u64Value)
424	{
425	char szValue[64];
426	RTStrPrintf(szValue, sizeof(szValue), "%#RX64", u64Value);
427	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
428	}
429
430
431	/**
432	* Sets a key value, does necessary error bitching.
433	*
434	* @returns COM status code.
435	* @param pMachine The Machine object.
436	* @param pszKeyBase The key base.
437	* @param pszKey The key.
438	* @param pszAttribute The attribute name.
439	* @param i64Value The value.
440	*/
441	static HRESULT SetInt64(ComPtr<IMachine> pMachine, const char pszKeyBase, const char pszKey, const char *pszAttribute, int64_t i64Value)
442	{
443	char szValue[64];
444	RTStrPrintf(szValue, sizeof(szValue), "%RI64", i64Value);
445	return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue);
446	}
447
448
449	/**
450	* Identical to the 'loadsyms' command.
451	*/
452	static RTEXITCODE CmdLoadSyms(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
453	{
454	HRESULT rc;
455
456	/*
457	* Get the VM
458	*/
459	ComPtr<IMachine> machine;
460	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
461	machine.asOutParam()), RTEXITCODE_FAILURE);
462
463	/*
464	* Parse the command.
465	*/
466	const char *pszFilename;
467	int64_t offDelta = 0;
468	const char *pszModule = NULL;
469	uint64_t ModuleAddress = ~0;
470	uint64_t ModuleSize = 0;
471
472	/* filename */
473	if (argc < 2)
474	return errorArgument("Missing the filename argument!\n");
475	pszFilename = argv[1];
476
477	/* offDelta */
478	if (argc >= 3)
479	{
480	int irc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta);
481	if (RT_FAILURE(irc))
482	return errorArgument(argv[0], "Failed to read delta '%s', rc=%Rrc\n", argv[2], rc);
483	}
484
485	/* pszModule */
486	if (argc >= 4)
487	pszModule = argv[3];
488
489	/* ModuleAddress */
490	if (argc >= 5)
491	{
492	int irc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress);
493	if (RT_FAILURE(irc))
494	return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[4], rc);
495	}
496
497	/* ModuleSize */
498	if (argc >= 6)
499	{
500	int irc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize);
501	if (RT_FAILURE(irc))
502	return errorArgument(argv[0], "Failed to read module size '%s', rc=%Rrc\n", argv[5], rc);
503	}
504
505	/*
506	* Add extra data.
507	*/
508	Utf8Str KeyStr;
509	HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
510	if (SUCCEEDED(hrc))
511	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Filename", pszFilename);
512	if (SUCCEEDED(hrc) && argc >= 3)
513	hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Delta", offDelta);
514	if (SUCCEEDED(hrc) && argc >= 4)
515	hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Module", pszModule);
516	if (SUCCEEDED(hrc) && argc >= 5)
517	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleAddress", ModuleAddress);
518	if (SUCCEEDED(hrc) && argc >= 6)
519	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleSize", ModuleSize);
520
521	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
522	}
523
524
525	/**
526	* Identical to the 'loadmap' command.
527	*/
528	static RTEXITCODE CmdLoadMap(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
529	{
530	HRESULT rc;
531
532	/*
533	* Get the VM
534	*/
535	ComPtr<IMachine> machine;
536	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
537	machine.asOutParam()), RTEXITCODE_FAILURE);
538
539	/*
540	* Parse the command.
541	*/
542	const char *pszFilename;
543	uint64_t ModuleAddress = UINT64_MAX;
544	const char *pszModule = NULL;
545	uint64_t offSubtrahend = 0;
546	uint32_t iSeg = UINT32_MAX;
547
548	/* filename */
549	if (argc < 2)
550	return errorArgument("Missing the filename argument!\n");
551	pszFilename = argv[1];
552
553	/* address */
554	if (argc < 3)
555	return errorArgument("Missing the module address argument!\n");
556	int irc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress);
557	if (RT_FAILURE(irc))
558	return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[2], rc);
559
560	/* name (optional) */
561	if (argc > 3)
562	pszModule = argv[3];
563
564	/* subtrahend (optional) */
565	if (argc > 4)
566	{
567	irc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend);
568	if (RT_FAILURE(irc))
569	return errorArgument(argv[0], "Failed to read subtrahend '%s', rc=%Rrc\n", argv[4], rc);
570	}
571
572	/* segment (optional) */
573	if (argc > 5)
574	{
575	irc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg);
576	if (RT_FAILURE(irc))
577	return errorArgument(argv[0], "Failed to read segment number '%s', rc=%Rrc\n", argv[5], rc);
578	}
579
580	/*
581	* Add extra data.
582	*/
583	Utf8Str KeyStr;
584	HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadmap", KeyStr);
585	if (SUCCEEDED(hrc))
586	hrc = SetString(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Filename", pszFilename);
587	if (SUCCEEDED(hrc))
588	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Address", ModuleAddress);
589	if (SUCCEEDED(hrc) && pszModule != NULL)
590	hrc = SetString(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Name", pszModule);
591	if (SUCCEEDED(hrc) && offSubtrahend != 0)
592	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Subtrahend", offSubtrahend);
593	if (SUCCEEDED(hrc) && iSeg != UINT32_MAX)
594	hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Segment", iSeg);
595
596	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
597	}
598
599
600	static DECLCALLBACK(void) handleVDError(void pvUser, int rc, RT_SRC_POS_DECL, const char pszFormat, va_list va)
601	{
602	RTMsgErrorV(pszFormat, va);
603	RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS);
604	}
605
606	static DECLCALLBACK(int) handleVDMessage(void pvUser, const char pszFormat, va_list va)
607	{
608	NOREF(pvUser);
609	return RTPrintfV(pszFormat, va);
610	}
611
612	static RTEXITCODE CmdSetHDUUID(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
613	{
614	Guid uuid;
615	RTUUID rtuuid;
616	enum eUuidType {
617	HDUUID,
618	HDPARENTUUID
619	} uuidType;
620
621	if (!strcmp(argv[0], "sethduuid"))
622	{
623	uuidType = HDUUID;
624	if (argc != 3 && argc != 2)
625	return errorSyntax(USAGE_SETHDUUID, "Not enough parameters");
626	/* if specified, take UUID, otherwise generate a new one */
627	if (argc == 3)
628	{
629	if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
630	return errorSyntax(USAGE_SETHDUUID, "Invalid UUID parameter");
631	uuid = argv[2];
632	} else
633	uuid.create();
634	}
635	else if (!strcmp(argv[0], "sethdparentuuid"))
636	{
637	uuidType = HDPARENTUUID;
638	if (argc != 3)
639	return errorSyntax(USAGE_SETHDPARENTUUID, "Not enough parameters");
640	if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2])))
641	return errorSyntax(USAGE_SETHDPARENTUUID, "Invalid UUID parameter");
642	uuid = argv[2];
643	}
644	else
645	return errorSyntax(USAGE_SETHDUUID, "Invalid invocation");
646
647	/* just try it */
648	char *pszFormat = NULL;
649	VDTYPE enmType = VDTYPE_INVALID;
650	int rc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
651	argv[1], &pszFormat, &enmType);
652	if (RT_FAILURE(rc))
653	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc);
654
655	PVBOXHDD pDisk = NULL;
656
657	PVDINTERFACE pVDIfs = NULL;
658	VDINTERFACEERROR vdInterfaceError;
659	vdInterfaceError.pfnError = handleVDError;
660	vdInterfaceError.pfnMessage = handleVDMessage;
661
662	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
663	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
664	AssertRC(rc);
665
666	rc = VDCreate(pVDIfs, enmType, &pDisk);
667	if (RT_FAILURE(rc))
668	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc);
669
670	/* Open the image */
671	rc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL \| VD_OPEN_FLAGS_INFO, NULL);
672	if (RT_FAILURE(rc))
673	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc);
674
675	if (uuidType == HDUUID)
676	rc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
677	else
678	rc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw());
679	if (RT_FAILURE(rc))
680	RTMsgError("Cannot set a new UUID: %Rrc", rc);
681	else
682	RTPrintf("UUID changed to: %s\n", uuid.toString().c_str());
683
684	VDCloseAll(pDisk);
685
686	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
687	}
688
689
690	static RTEXITCODE CmdDumpHDInfo(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
691	{
692	/* we need exactly one parameter: the image file */
693	if (argc != 1)
694	{
695	return errorSyntax(USAGE_DUMPHDINFO, "Not enough parameters");
696	}
697
698	/* just try it */
699	char *pszFormat = NULL;
700	VDTYPE enmType = VDTYPE_INVALID;
701	int rc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
702	argv[0], &pszFormat, &enmType);
703	if (RT_FAILURE(rc))
704	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc);
705
706	PVBOXHDD pDisk = NULL;
707
708	PVDINTERFACE pVDIfs = NULL;
709	VDINTERFACEERROR vdInterfaceError;
710	vdInterfaceError.pfnError = handleVDError;
711	vdInterfaceError.pfnMessage = handleVDMessage;
712
713	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
714	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
715	AssertRC(rc);
716
717	rc = VDCreate(pVDIfs, enmType, &pDisk);
718	if (RT_FAILURE(rc))
719	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc);
720
721	/* Open the image */
722	rc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO, NULL);
723	if (RT_FAILURE(rc))
724	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc);
725
726	VDDumpImages(pDisk);
727
728	VDCloseAll(pDisk);
729
730	return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
731	}
732
733	static int partRead(RTFILE File, PHOSTPARTITIONS pPart)
734	{
735	uint8_t aBuffer[512];
736	uint8_t partitionTableHeader[512];
737	uint32_t sector_size = 512;
738	uint64_t lastUsableLBA = 0;
739	int rc;
740
741	VBOXHDDPARTTYPE partitioningType;
742
743	pPart->cPartitions = 0;
744	memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions));
745
746	rc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL);
747	if (RT_FAILURE(rc))
748	return rc;
749
750	if (aBuffer[450] == 0xEE)/* check the sign of the GPT disk*/
751	{
752	partitioningType = GPT;
753	pPart->uPartitioningType = GPT;//partitioningType;
754
755	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
756	return VERR_INVALID_PARAMETER;
757
758	rc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL);
759	if (RT_SUCCESS(rc))
760	{
761	/** @todo r=bird: This is a 64-bit magic value, right... */
762	const char l_ppth = (char )partitionTableHeader;
763	if (strncmp(l_ppth, "EFI PART", 8))
764	return VERR_INVALID_PARAMETER;
765
766	/** @todo check GPT Version */
767
768	/** @todo r=bird: C have this handy concept called structures which
769	* greatly simplify data access... (Someone is really lazy here!) */
770	uint64_t firstUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[40],
771	partitionTableHeader[41],
772	partitionTableHeader[42],
773	partitionTableHeader[43],
774	partitionTableHeader[44],
775	partitionTableHeader[45],
776	partitionTableHeader[46],
777	partitionTableHeader[47]
778	);
779	lastUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[48],
780	partitionTableHeader[49],
781	partitionTableHeader[50],
782	partitionTableHeader[51],
783	partitionTableHeader[52],
784	partitionTableHeader[53],
785	partitionTableHeader[54],
786	partitionTableHeader[55]
787	);
788	uint32_t partitionsNumber = RT_MAKE_U32_FROM_U8(partitionTableHeader[80],
789	partitionTableHeader[81],
790	partitionTableHeader[82],
791	partitionTableHeader[83]
792	);
793	uint32_t partitionEntrySize = RT_MAKE_U32_FROM_U8(partitionTableHeader[84],
794	partitionTableHeader[85],
795	partitionTableHeader[86],
796	partitionTableHeader[87]
797	);
798
799	uint32_t currentEntry = 0;
800
801	if (partitionEntrySize * partitionsNumber > 4 * _1M)
802	{
803	RTMsgError("The GPT header seems corrupt because it contains too many entries");
804	return VERR_INVALID_PARAMETER;
805	}
806
807	uint8_t pbPartTable = (uint8_t )RTMemAllocZ(RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512));
808	if (!pbPartTable)
809	{
810	RTMsgError("Allocating memory for the GPT partitions entries failed");
811	return VERR_NO_MEMORY;
812	}
813
814	/* partition entries begin from LBA2 */
815	/** @todo r=aeichner: Reading from LBA 2 is not always correct, the header will contain the starting LBA. */
816	rc = RTFileReadAt(File, 1024, pbPartTable, RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512), NULL);
817	if (RT_FAILURE(rc))
818	{
819	RTMsgError("Reading the partition table failed");
820	RTMemFree(pbPartTable);
821	return rc;
822	}
823
824	while (currentEntry < partitionsNumber)
825	{
826	uint8_t partitionEntry = pbPartTable + currentEntry partitionEntrySize;
827
828	uint64_t start = RT_MAKE_U64_FROM_U8(partitionEntry[32], partitionEntry[33], partitionEntry[34], partitionEntry[35],
829	partitionEntry[36], partitionEntry[37], partitionEntry[38], partitionEntry[39]);
830	uint64_t end = RT_MAKE_U64_FROM_U8(partitionEntry[40], partitionEntry[41], partitionEntry[42], partitionEntry[43],
831	partitionEntry[44], partitionEntry[45], partitionEntry[46], partitionEntry[47]);
832
833	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
834	pCP->uIndex = currentEntry + 1;
835	pCP->uIndexWin = currentEntry + 1;
836	pCP->uType = 0;
837	pCP->uStartCylinder = 0;
838	pCP->uStartHead = 0;
839	pCP->uStartSector = 0;
840	pCP->uEndCylinder = 0;
841	pCP->uEndHead = 0;
842	pCP->uEndSector = 0;
843	pCP->uPartDataStart = 0; /* will be filled out later properly. */
844	pCP->cPartDataSectors = 0;
845	if (start==0 \|\| end==0)
846	{
847	pCP->uIndex = 0;
848	pCP->uIndexWin = 0;
849	--pPart->cPartitions;
850	break;
851	}
852	else
853	{
854	pCP->uStart = start;
855	pCP->uSize = (end +1) - start;/+1 LBA because the last address is included/
856	}
857
858	++currentEntry;
859	}
860
861	RTMemFree(pbPartTable);
862	}
863	}
864	else
865	{
866	partitioningType = MBR;
867	pPart->uPartitioningType = MBR;//partitioningType;
868
869	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
870	return VERR_INVALID_PARAMETER;
871
872	unsigned uExtended = (unsigned)-1;
873	unsigned uIndexWin = 1;
874
875	for (unsigned i = 0; i < 4; i++)
876	{
877	uint8_t p = &aBuffer[0x1be + i 16];
878	if (p[4] == 0)
879	continue;
880	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
881	pCP->uIndex = i + 1;
882	pCP->uType = p[4];
883	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
884	pCP->uStartHead = p[1];
885	pCP->uStartSector = p[2] & 0x3f;
886	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
887	pCP->uEndHead = p[5];
888	pCP->uEndSector = p[6] & 0x3f;
889	pCP->uStart = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
890	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
891	pCP->uPartDataStart = 0; /* will be filled out later properly. */
892	pCP->cPartDataSectors = 0;
893
894	if (PARTTYPE_IS_EXTENDED(p[4]))
895	{
896	if (uExtended == (unsigned)-1)
897	{
898	uExtended = (unsigned)(pCP - pPart->aPartitions);
899	pCP->uIndexWin = 0;
900	}
901	else
902	{
903	RTMsgError("More than one extended partition");
904	return VERR_INVALID_PARAMETER;
905	}
906	}
907	else
908	{
909	pCP->uIndexWin = uIndexWin;
910	uIndexWin++;
911	}
912	}
913
914	if (uExtended != (unsigned)-1)
915	{
916	unsigned uIndex = 5;
917	uint64_t uStart = pPart->aPartitions[uExtended].uStart;
918	uint64_t uOffset = 0;
919	if (!uStart)
920	{
921	RTMsgError("Inconsistency for logical partition start");
922	return VERR_INVALID_PARAMETER;
923	}
924
925	do
926	{
927	rc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL);
928	if (RT_FAILURE(rc))
929	return rc;
930
931	if (aBuffer[510] != 0x55 \|\| aBuffer[511] != 0xaa)
932	{
933	RTMsgError("Logical partition without magic");
934	return VERR_INVALID_PARAMETER;
935	}
936	uint8_t *p = &aBuffer[0x1be];
937
938	if (p[4] == 0)
939	{
940	RTMsgError("Logical partition with type 0 encountered");
941	return VERR_INVALID_PARAMETER;
942	}
943
944	PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++];
945	pCP->uIndex = uIndex;
946	pCP->uIndexWin = uIndexWin;
947	pCP->uType = p[4];
948	pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2);
949	pCP->uStartHead = p[1];
950	pCP->uStartSector = p[2] & 0x3f;
951	pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2);
952	pCP->uEndHead = p[5];
953	pCP->uEndSector = p[6] & 0x3f;
954	uint32_t uStartOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
955	if (!uStartOffset)
956	{
957	RTMsgError("Invalid partition start offset");
958	return VERR_INVALID_PARAMETER;
959	}
960	pCP->uStart = uStart + uOffset + uStartOffset;
961	pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]);
962	/* Fill out partitioning location info for EBR. */
963	pCP->uPartDataStart = uStart + uOffset;
964	pCP->cPartDataSectors = uStartOffset;
965	p += 16;
966	if (p[4] == 0)
967	uExtended = (unsigned)-1;
968	else if (PARTTYPE_IS_EXTENDED(p[4]))
969	{
970	uExtended = uIndex;
971	uIndex++;
972	uIndexWin++;
973	uOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]);
974	}
975	else
976	{
977	RTMsgError("Logical partition chain broken");
978	return VERR_INVALID_PARAMETER;
979	}
980	} while (uExtended != (unsigned)-1);
981	}
982	}
983
984
985	/* Sort partitions in ascending order of start sector, plus a trivial
986	* bit of consistency checking. */
987	for (unsigned i = 0; i < pPart->cPartitions-1; i++)
988	{
989	unsigned uMinIdx = i;
990	uint64_t uMinVal = pPart->aPartitions[i].uStart;
991	for (unsigned j = i + 1; j < pPart->cPartitions; j++)
992	{
993	if (pPart->aPartitions[j].uStart < uMinVal)
994	{
995	uMinIdx = j;
996	uMinVal = pPart->aPartitions[j].uStart;
997	}
998	else if (pPart->aPartitions[j].uStart == uMinVal)
999	{
1000	RTMsgError("Two partitions start at the same place");
1001	return VERR_INVALID_PARAMETER;
1002	}
1003	else if (pPart->aPartitions[j].uStart == 0)
1004	{
1005	RTMsgError("Partition starts at sector 0");
1006	return VERR_INVALID_PARAMETER;
1007	}
1008	}
1009	if (uMinIdx != i)
1010	{
1011	/* Swap entries at index i and uMinIdx. */
1012	memcpy(&pPart->aPartitions[pPart->cPartitions],
1013	&pPart->aPartitions[i], sizeof(HOSTPARTITION));
1014	memcpy(&pPart->aPartitions[i],
1015	&pPart->aPartitions[uMinIdx], sizeof(HOSTPARTITION));
1016	memcpy(&pPart->aPartitions[uMinIdx],
1017	&pPart->aPartitions[pPart->cPartitions], sizeof(HOSTPARTITION));
1018	}
1019	}
1020
1021	/* Fill out partitioning location info for MBR or GPT. */
1022	pPart->aPartitions[0].uPartDataStart = 0;
1023	pPart->aPartitions[0].cPartDataSectors = pPart->aPartitions[0].uStart;
1024
1025	/* Fill out partitioning location info for backup GPT. */
1026	if (partitioningType == GPT)
1027	{
1028	pPart->aPartitions[pPart->cPartitions-1].uPartDataStart = lastUsableLBA+1;
1029	pPart->aPartitions[pPart->cPartitions-1].cPartDataSectors = 33;
1030
1031	/* Now do a some partition table consistency checking, to reject the most
1032	* obvious garbage which can lead to trouble later. */
1033	uint64_t uPrevEnd = 0;
1034	for (unsigned i = 0; i < pPart->cPartitions; i++)
1035	{
1036	if (pPart->aPartitions[i].cPartDataSectors)
1037	uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors;
1038	if (pPart->aPartitions[i].uStart < uPrevEnd &&
1039	pPart->cPartitions-1 != i)
1040	{
1041	RTMsgError("Overlapping GPT partitions");
1042	return VERR_INVALID_PARAMETER;
1043	}
1044	}
1045	}
1046	else
1047	{
1048	/* Now do a some partition table consistency checking, to reject the most
1049	* obvious garbage which can lead to trouble later. */
1050	uint64_t uPrevEnd = 0;
1051	for (unsigned i = 0; i < pPart->cPartitions; i++)
1052	{
1053	if (pPart->aPartitions[i].cPartDataSectors)
1054	uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors;
1055	if (pPart->aPartitions[i].uStart < uPrevEnd)
1056	{
1057	RTMsgError("Overlapping MBR partitions");
1058	return VERR_INVALID_PARAMETER;
1059	}
1060	if (!PARTTYPE_IS_EXTENDED(pPart->aPartitions[i].uType))
1061	uPrevEnd = pPart->aPartitions[i].uStart + pPart->aPartitions[i].uSize;
1062	}
1063	}
1064
1065	return VINF_SUCCESS;
1066	}
1067
1068	static RTEXITCODE CmdListPartitions(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1069	{
1070	Utf8Str rawdisk;
1071
1072	/* let's have a closer look at the arguments */
1073	for (int i = 0; i < argc; i++)
1074	{
1075	if (strcmp(argv[i], "-rawdisk") == 0)
1076	{
1077	if (argc <= i + 1)
1078	{
1079	return errorArgument("Missing argument to '%s'", argv[i]);
1080	}
1081	i++;
1082	rawdisk = argv[i];
1083	}
1084	else
1085	{
1086	return errorSyntax(USAGE_LISTPARTITIONS, "Invalid parameter '%s'", argv[i]);
1087	}
1088	}
1089
1090	if (rawdisk.isEmpty())
1091	return errorSyntax(USAGE_LISTPARTITIONS, "Mandatory parameter -rawdisk missing");
1092
1093	RTFILE hRawFile;
1094	int vrc = RTFileOpen(&hRawFile, rawdisk.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1095	if (RT_FAILURE(vrc))
1096	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the raw disk: %Rrc", vrc);
1097
1098	HOSTPARTITIONS partitions;
1099	vrc = partRead(hRawFile, &partitions);
1100	/* Don't bail out on errors, print the table and return the result code. */
1101
1102	RTPrintf("Number Type StartCHS EndCHS Size (MiB) Start (Sect)\n");
1103	for (unsigned i = 0; i < partitions.cPartitions; i++)
1104	{
1105	/* Don't show the extended partition, otherwise users might think they
1106	* can add it to the list of partitions for raw partition access. */
1107	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1108	continue;
1109
1110	RTPrintf("%-7u %#04x %-4u/%-3u/%-2u %-4u/%-3u/%-2u %10llu %10llu\n",
1111	partitions.aPartitions[i].uIndex,
1112	partitions.aPartitions[i].uType,
1113	partitions.aPartitions[i].uStartCylinder,
1114	partitions.aPartitions[i].uStartHead,
1115	partitions.aPartitions[i].uStartSector,
1116	partitions.aPartitions[i].uEndCylinder,
1117	partitions.aPartitions[i].uEndHead,
1118	partitions.aPartitions[i].uEndSector,
1119	partitions.aPartitions[i].uSize / 2048,
1120	partitions.aPartitions[i].uStart);
1121	}
1122
1123	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1124	}
1125
1126	static PVBOXHDDRAWPARTDESC appendPartDesc(uint32_t pcPartDescs, PVBOXHDDRAWPARTDESC ppPartDescs)
1127	{
1128	(*pcPartDescs)++;
1129	PVBOXHDDRAWPARTDESC p;
1130	p = (PVBOXHDDRAWPARTDESC)RTMemRealloc(*ppPartDescs,
1131	pcPartDescs sizeof(VBOXHDDRAWPARTDESC));
1132	*ppPartDescs = p;
1133	if (p)
1134	{
1135	p = p + *pcPartDescs - 1;
1136	memset(p, '\0', sizeof(VBOXHDDRAWPARTDESC));
1137	}
1138
1139	return p;
1140	}
1141
1142	static RTEXITCODE CmdCreateRawVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1143	{
1144	HRESULT rc = S_OK;
1145	Utf8Str filename;
1146	const char *pszMBRFilename = NULL;
1147	Utf8Str rawdisk;
1148	const char *pszPartitions = NULL;
1149	bool fRelative = false;
1150
1151	uint64_t cbSize = 0;
1152	PVBOXHDD pDisk = NULL;
1153	VBOXHDDRAW RawDescriptor;
1154	PVDINTERFACE pVDIfs = NULL;
1155
1156	/* let's have a closer look at the arguments */
1157	for (int i = 0; i < argc; i++)
1158	{
1159	if (strcmp(argv[i], "-filename") == 0)
1160	{
1161	if (argc <= i + 1)
1162	{
1163	return errorArgument("Missing argument to '%s'", argv[i]);
1164	}
1165	i++;
1166	filename = argv[i];
1167	}
1168	else if (strcmp(argv[i], "-mbr") == 0)
1169	{
1170	if (argc <= i + 1)
1171	{
1172	return errorArgument("Missing argument to '%s'", argv[i]);
1173	}
1174	i++;
1175	pszMBRFilename = argv[i];
1176	}
1177	else if (strcmp(argv[i], "-rawdisk") == 0)
1178	{
1179	if (argc <= i + 1)
1180	{
1181	return errorArgument("Missing argument to '%s'", argv[i]);
1182	}
1183	i++;
1184	rawdisk = argv[i];
1185	}
1186	else if (strcmp(argv[i], "-partitions") == 0)
1187	{
1188	if (argc <= i + 1)
1189	{
1190	return errorArgument("Missing argument to '%s'", argv[i]);
1191	}
1192	i++;
1193	pszPartitions = argv[i];
1194	}
1195	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD) \|\| defined(RT_OS_WINDOWS)
1196	else if (strcmp(argv[i], "-relative") == 0)
1197	{
1198	fRelative = true;
1199	}
1200	#endif /* RT_OS_LINUX \|\| RT_OS_FREEBSD */
1201	else
1202	return errorSyntax(USAGE_CREATERAWVMDK, "Invalid parameter '%s'", argv[i]);
1203	}
1204
1205	if (filename.isEmpty())
1206	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -filename missing");
1207	if (rawdisk.isEmpty())
1208	return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -rawdisk missing");
1209	if (!pszPartitions && pszMBRFilename)
1210	return errorSyntax(USAGE_CREATERAWVMDK, "The parameter -mbr is only valid when the parameter -partitions is also present");
1211
1212	#ifdef RT_OS_DARWIN
1213	fRelative = true;
1214	#endif /* RT_OS_DARWIN */
1215	RTFILE hRawFile;
1216	int vrc = RTFileOpen(&hRawFile, rawdisk.c_str(), RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1217	if (RT_FAILURE(vrc))
1218	{
1219	RTMsgError("Cannot open the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1220	goto out;
1221	}
1222
1223	#ifdef RT_OS_WINDOWS
1224	/* Windows NT has no IOCTL_DISK_GET_LENGTH_INFORMATION ioctl. This was
1225	* added to Windows XP, so we have to use the available info from DriveGeo.
1226	* Note that we cannot simply use IOCTL_DISK_GET_DRIVE_GEOMETRY as it
1227	* yields a slightly different result than IOCTL_DISK_GET_LENGTH_INFO.
1228	* We call IOCTL_DISK_GET_DRIVE_GEOMETRY first as we need to check the media
1229	* type anyway, and if IOCTL_DISK_GET_LENGTH_INFORMATION is supported
1230	* we will later override cbSize.
1231	*/
1232	DISK_GEOMETRY DriveGeo;
1233	DWORD cbDriveGeo;
1234	if (DeviceIoControl((HANDLE)RTFileToNative(hRawFile),
1235	IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
1236	&DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL))
1237	{
1238	if ( DriveGeo.MediaType == FixedMedia
1239	\|\| DriveGeo.MediaType == RemovableMedia)
1240	{
1241	cbSize = DriveGeo.Cylinders.QuadPart
1242	* DriveGeo.TracksPerCylinder
1243	* DriveGeo.SectorsPerTrack
1244	* DriveGeo.BytesPerSector;
1245	}
1246	else
1247	{
1248	RTMsgError("File '%s' is no fixed/removable medium device", rawdisk.c_str());
1249	vrc = VERR_INVALID_PARAMETER;
1250	goto out;
1251	}
1252
1253	GET_LENGTH_INFORMATION DiskLenInfo;
1254	DWORD junk;
1255	if (DeviceIoControl((HANDLE)RTFileToNative(hRawFile),
1256	IOCTL_DISK_GET_LENGTH_INFO, NULL, 0,
1257	&DiskLenInfo, sizeof(DiskLenInfo), &junk, (LPOVERLAPPED)NULL))
1258	{
1259	/* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */
1260	cbSize = DiskLenInfo.Length.QuadPart;
1261	}
1262	if ( fRelative
1263	&& !rawdisk.startsWith("\\\\.\\PhysicalDrive", Utf8Str::CaseInsensitive))
1264	{
1265	RTMsgError("The -relative parameter is invalid for raw disk %s", rawdisk.c_str());
1266	vrc = VERR_INVALID_PARAMETER;
1267	goto out;
1268	}
1269	}
1270	else
1271	{
1272	/*
1273	* Could be raw image, remember error code and try to get the size first
1274	* before failing.
1275	*/
1276	vrc = RTErrConvertFromWin32(GetLastError());
1277	if (RT_FAILURE(RTFileGetSize(hRawFile, &cbSize)))
1278	{
1279	RTMsgError("Cannot get the geometry of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1280	goto out;
1281	}
1282	else
1283	{
1284	if (fRelative)
1285	{
1286	RTMsgError("The -relative parameter is invalid for raw images");
1287	vrc = VERR_INVALID_PARAMETER;
1288	goto out;
1289	}
1290	vrc = VINF_SUCCESS;
1291	}
1292	}
1293	#elif defined(RT_OS_LINUX)
1294	struct stat DevStat;
1295	if (!fstat(RTFileToNative(hRawFile), &DevStat))
1296	{
1297	if (S_ISBLK(DevStat.st_mode))
1298	{
1299	#ifdef BLKGETSIZE64
1300	/* BLKGETSIZE64 is broken up to 2.4.17 and in many 2.5.x. In 2.6.0
1301	* it works without problems. */
1302	struct utsname utsname;
1303	if ( uname(&utsname) == 0
1304	&& ( (strncmp(utsname.release, "2.5.", 4) == 0 && atoi(&utsname.release[4]) >= 18)
1305	\|\| (strncmp(utsname.release, "2.", 2) == 0 && atoi(&utsname.release[2]) >= 6)))
1306	{
1307	uint64_t cbBlk;
1308	if (!ioctl(RTFileToNative(hRawFile), BLKGETSIZE64, &cbBlk))
1309	cbSize = cbBlk;
1310	}
1311	#endif /* BLKGETSIZE64 */
1312	if (!cbSize)
1313	{
1314	long cBlocks;
1315	if (!ioctl(RTFileToNative(hRawFile), BLKGETSIZE, &cBlocks))
1316	cbSize = (uint64_t)cBlocks << 9;
1317	else
1318	{
1319	vrc = RTErrConvertFromErrno(errno);
1320	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1321	goto out;
1322	}
1323	}
1324	}
1325	else if (S_ISREG(DevStat.st_mode))
1326	{
1327	vrc = RTFileGetSize(hRawFile, &cbSize);
1328	if (RT_FAILURE(vrc))
1329	{
1330	RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
1331	goto out;
1332	}
1333	else if (fRelative)
1334	{
1335	RTMsgError("The -relative parameter is invalid for raw images");
1336	vrc = VERR_INVALID_PARAMETER;
1337	goto out;
1338	}
1339	}
1340	else
1341	{
1342	RTMsgError("File '%s' is no block device", rawdisk.c_str());
1343	vrc = VERR_INVALID_PARAMETER;
1344	goto out;
1345	}
1346	}
1347	else
1348	{
1349	vrc = RTErrConvertFromErrno(errno);
1350	RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
1351	rawdisk.c_str(), vrc);
1352	}
1353	#elif defined(RT_OS_DARWIN)
1354	struct stat DevStat;
1355	if (!fstat(RTFileToNative(hRawFile), &DevStat))
1356	{
1357	if (S_ISBLK(DevStat.st_mode))
1358	{
1359	uint64_t cBlocks;
1360	uint32_t cbBlock;
1361	if (!ioctl(RTFileToNative(hRawFile), DKIOCGETBLOCKCOUNT, &cBlocks))
1362	{
1363	if (!ioctl(RTFileToNative(hRawFile), DKIOCGETBLOCKSIZE, &cbBlock))
1364	cbSize = cBlocks * cbBlock;
1365	else
1366	{
1367	RTMsgError("Cannot get the block size for file '%s': %Rrc", rawdisk.c_str(), vrc);
1368	vrc = RTErrConvertFromErrno(errno);
1369	goto out;
1370	}
1371	}
1372	else
1373	{
1374	vrc = RTErrConvertFromErrno(errno);
1375	RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
1376	goto out;
1377	}
1378	}
1379	else if (S_ISREG(DevStat.st_mode))
1380	{
1381	fRelative = false; /* Must be false for raw image files. */
1382	vrc = RTFileGetSize(hRawFile, &cbSize);
1383	if (RT_FAILURE(vrc))
1384	{
1385	RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
1386	goto out;
1387	}
1388	}
1389	else
1390	{
1391	RTMsgError("File '%s' is neither block device nor regular file", rawdisk.c_str());
1392	vrc = VERR_INVALID_PARAMETER;
1393	goto out;
1394	}
1395	}
1396	else
1397	{
1398	vrc = RTErrConvertFromErrno(errno);
1399	RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
1400	rawdisk.c_str(), vrc);
1401	}
1402	#elif defined(RT_OS_SOLARIS)
1403	struct stat DevStat;
1404	if (!fstat(RTFileToNative(hRawFile), &DevStat))
1405	{
1406	if (S_ISBLK(DevStat.st_mode) \|\| S_ISCHR(DevStat.st_mode))
1407	{
1408	struct dk_minfo mediainfo;
1409	if (!ioctl(RTFileToNative(hRawFile), DKIOCGMEDIAINFO, &mediainfo))
1410	cbSize = mediainfo.dki_capacity * mediainfo.dki_lbsize;
1411	else
1412	{
1413	vrc = RTErrConvertFromErrno(errno);
1414	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1415	goto out;
1416	}
1417	}
1418	else if (S_ISREG(DevStat.st_mode))
1419	{
1420	vrc = RTFileGetSize(hRawFile, &cbSize);
1421	if (RT_FAILURE(vrc))
1422	{
1423	RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc);
1424	goto out;
1425	}
1426	}
1427	else
1428	{
1429	RTMsgError("File '%s' is no block or char device", rawdisk.c_str());
1430	vrc = VERR_INVALID_PARAMETER;
1431	goto out;
1432	}
1433	}
1434	else
1435	{
1436	vrc = RTErrConvertFromErrno(errno);
1437	RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
1438	rawdisk.c_str(), vrc);
1439	}
1440	#elif defined(RT_OS_FREEBSD)
1441	struct stat DevStat;
1442	if (!fstat(RTFileToNative(hRawFile), &DevStat))
1443	{
1444	if (S_ISCHR(DevStat.st_mode))
1445	{
1446	off_t cbMedia = 0;
1447	if (!ioctl(RTFileToNative(hRawFile), DIOCGMEDIASIZE, &cbMedia))
1448	cbSize = cbMedia;
1449	else
1450	{
1451	vrc = RTErrConvertFromErrno(errno);
1452	RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc);
1453	goto out;
1454	}
1455	}
1456	else if (S_ISREG(DevStat.st_mode))
1457	{
1458	if (fRelative)
1459	{
1460	RTMsgError("The -relative parameter is invalid for raw images");
1461	vrc = VERR_INVALID_PARAMETER;
1462	goto out;
1463	}
1464	cbSize = DevStat.st_size;
1465	}
1466	else
1467	{
1468	RTMsgError("File '%s' is neither character device nor regular file", rawdisk.c_str());
1469	vrc = VERR_INVALID_PARAMETER;
1470	goto out;
1471	}
1472	}
1473	else
1474	{
1475	vrc = RTErrConvertFromErrno(errno);
1476	RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc",
1477	rawdisk.c_str(), vrc);
1478	}
1479	#else /* all unrecognized OSes */
1480	/* Hopefully this works on all other hosts. If it doesn't, it'll just fail
1481	* creating the VMDK, so no real harm done. */
1482	vrc = RTFileGetSize(hRawFile, &cbSize);
1483	if (RT_FAILURE(vrc))
1484	{
1485	RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc);
1486	goto out;
1487	}
1488	#endif
1489
1490	/* Check whether cbSize is actually sensible. */
1491	if (!cbSize \|\| cbSize % 512)
1492	{
1493	RTMsgError("Detected size of raw disk '%s' is %s, an invalid value", rawdisk.c_str(), cbSize);
1494	vrc = VERR_INVALID_PARAMETER;
1495	goto out;
1496	}
1497
1498	RawDescriptor.szSignature[0] = 'R';
1499	RawDescriptor.szSignature[1] = 'A';
1500	RawDescriptor.szSignature[2] = 'W';
1501	RawDescriptor.szSignature[3] = '\0';
1502	if (!pszPartitions)
1503	{
1504	RawDescriptor.uFlags = VBOXHDDRAW_DISK;
1505	RawDescriptor.pszRawDisk = rawdisk.c_str();
1506	}
1507	else
1508	{
1509	RawDescriptor.uFlags = VBOXHDDRAW_NORMAL;
1510	RawDescriptor.pszRawDisk = NULL;
1511	RawDescriptor.cPartDescs = 0;
1512	RawDescriptor.pPartDescs = NULL;
1513
1514	uint32_t uPartitions = 0;
1515	uint32_t uPartitionsRO = 0;
1516
1517	const char *p = pszPartitions;
1518	char *pszNext;
1519	uint32_t u32;
1520	while (*p != '\0')
1521	{
1522	vrc = RTStrToUInt32Ex(p, &pszNext, 0, &u32);
1523	if (RT_FAILURE(vrc))
1524	{
1525	RTMsgError("Incorrect value in partitions parameter");
1526	goto out;
1527	}
1528	uPartitions \|= RT_BIT(u32);
1529	p = pszNext;
1530	if (*p == 'r')
1531	{
1532	uPartitionsRO \|= RT_BIT(u32);
1533	p++;
1534	}
1535	if (*p == ',')
1536	p++;
1537	else if (*p != '\0')
1538	{
1539	RTMsgError("Incorrect separator in partitions parameter");
1540	vrc = VERR_INVALID_PARAMETER;
1541	goto out;
1542	}
1543	}
1544
1545	HOSTPARTITIONS partitions;
1546	vrc = partRead(hRawFile, &partitions);
1547	if (RT_FAILURE(vrc))
1548	{
1549	RTMsgError("Cannot read the partition information from '%s'", rawdisk.c_str());
1550	goto out;
1551	}
1552
1553	RawDescriptor.uPartitioningType = partitions.uPartitioningType;
1554
1555	for (unsigned i = 0; i < partitions.cPartitions; i++)
1556	{
1557	if ( uPartitions & RT_BIT(partitions.aPartitions[i].uIndex)
1558	&& PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1559	{
1560	/* Some ignorant user specified an extended partition.
1561	* Bad idea, as this would trigger an overlapping
1562	* partitions error later during VMDK creation. So warn
1563	* here and ignore what the user requested. */
1564	RTMsgWarning("It is not possible (and necessary) to explicitly give access to the "
1565	"extended partition %u. If required, enable access to all logical "
1566	"partitions inside this extended partition.",
1567	partitions.aPartitions[i].uIndex);
1568	uPartitions &= ~RT_BIT(partitions.aPartitions[i].uIndex);
1569	}
1570	}
1571
1572	for (unsigned i = 0; i < partitions.cPartitions; i++)
1573	{
1574	PVBOXHDDRAWPARTDESC pPartDesc = NULL;
1575
1576	/* first dump the MBR/EPT data area */
1577	if (partitions.aPartitions[i].cPartDataSectors)
1578	{
1579	pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs,
1580	&RawDescriptor.pPartDescs);
1581	if (!pPartDesc)
1582	{
1583	RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
1584	vrc = VERR_NO_MEMORY;
1585	goto out;
1586	}
1587
1588	/** @todo the clipping below isn't 100% accurate, as it should
1589	* actually clip to the track size. However, that's easier said
1590	* than done as figuring out the track size is heuristics. In
1591	* any case the clipping is adjusted later after sorting, to
1592	* prevent overlapping data areas on the resulting image. */
1593	pPartDesc->cbData = RT_MIN(partitions.aPartitions[i].cPartDataSectors, 63) * 512;
1594	pPartDesc->uStart = partitions.aPartitions[i].uPartDataStart * 512;
1595	Assert(pPartDesc->cbData - (size_t)pPartDesc->cbData == 0);
1596	void *pPartData = RTMemAlloc((size_t)pPartDesc->cbData);
1597	if (!pPartData)
1598	{
1599	RTMsgError("Out of memory allocating the partition descriptor for '%s'", rawdisk.c_str());
1600	vrc = VERR_NO_MEMORY;
1601	goto out;
1602	}
1603	vrc = RTFileReadAt(hRawFile, partitions.aPartitions[i].uPartDataStart * 512,
1604	pPartData, (size_t)pPartDesc->cbData, NULL);
1605	if (RT_FAILURE(vrc))
1606	{
1607	RTMsgError("Cannot read partition data from raw device '%s': %Rrc", rawdisk.c_str(), vrc);
1608	goto out;
1609	}
1610	/* Splice in the replacement MBR code if specified. */
1611	if ( partitions.aPartitions[i].uPartDataStart == 0
1612	&& pszMBRFilename)
1613	{
1614	RTFILE MBRFile;
1615	vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
1616	if (RT_FAILURE(vrc))
1617	{
1618	RTMsgError("Cannot open replacement MBR file '%s' specified with -mbr: %Rrc", pszMBRFilename, vrc);
1619	goto out;
1620	}
1621	vrc = RTFileReadAt(MBRFile, 0, pPartData, 0x1be, NULL);
1622	RTFileClose(MBRFile);
1623	if (RT_FAILURE(vrc))
1624	{
1625	RTMsgError("Cannot read replacement MBR file '%s': %Rrc", pszMBRFilename, vrc);
1626	goto out;
1627	}
1628	}
1629	pPartDesc->pvPartitionData = pPartData;
1630	}
1631
1632	if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType))
1633	{
1634	/* Suppress exporting the actual extended partition. Only
1635	* logical partitions should be processed. However completely
1636	* ignoring it leads to leaving out the EBR data. */
1637	continue;
1638	}
1639
1640	/* set up values for non-relative device names */
1641	const char *pszRawName = rawdisk.c_str();
1642	uint64_t uStartOffset = partitions.aPartitions[i].uStart * 512;
1643
1644	pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs,
1645	&RawDescriptor.pPartDescs);
1646	if (!pPartDesc)
1647	{
1648	RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str());
1649	vrc = VERR_NO_MEMORY;
1650	goto out;
1651	}
1652
1653	if (uPartitions & RT_BIT(partitions.aPartitions[i].uIndex))
1654	{
1655	if (uPartitionsRO & RT_BIT(partitions.aPartitions[i].uIndex))
1656	pPartDesc->uFlags \|= VBOXHDDRAW_READONLY;
1657
1658	if (fRelative)
1659	{
1660	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_FREEBSD)
1661	/* Refer to the correct partition and use offset 0. */
1662	char *psz;
1663	RTStrAPrintf(&psz,
1664	#if defined(RT_OS_LINUX)
1665	"%s%u",
1666	#elif defined(RT_OS_DARWIN) \|\| defined(RT_OS_FREEBSD)
1667	"%ss%u",
1668	#endif
1669	rawdisk.c_str(),
1670	partitions.aPartitions[i].uIndex);
1671	if (!psz)
1672	{
1673	vrc = VERR_NO_STR_MEMORY;
1674	RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc",
1675	partitions.aPartitions[i].uIndex, vrc);
1676	goto out;
1677	}
1678	pszRawName = psz;
1679	uStartOffset = 0;
1680	#elif defined(RT_OS_WINDOWS)
1681	/* Refer to the correct partition and use offset 0. */
1682	char *psz;
1683	RTStrAPrintf(&psz, "\\\\.\\Harddisk%sPartition%u",
1684	rawdisk.c_str() + 17,
1685	partitions.aPartitions[i].uIndexWin);
1686	if (!psz)
1687	{
1688	vrc = VERR_NO_STR_MEMORY;
1689	RTMsgError("Cannot create reference to individual partition %u (numbered %u), rc=%Rrc",
1690	partitions.aPartitions[i].uIndex, partitions.aPartitions[i].uIndexWin, vrc);
1691	goto out;
1692	}
1693	pszRawName = psz;
1694	uStartOffset = 0;
1695	#else
1696	/** @todo not implemented for other hosts. Treat just like
1697	* not specified (this code is actually never reached). */
1698	#endif
1699	}
1700
1701	pPartDesc->pszRawDevice = pszRawName;
1702	pPartDesc->uStartOffset = uStartOffset;
1703	}
1704	else
1705	{
1706	pPartDesc->pszRawDevice = NULL;
1707	pPartDesc->uStartOffset = 0;
1708	}
1709
1710	pPartDesc->uStart = partitions.aPartitions[i].uStart * 512;
1711	pPartDesc->cbData = partitions.aPartitions[i].uSize * 512;
1712	}
1713
1714	/* Sort data areas in ascending order of start. */
1715	for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++)
1716	{
1717	unsigned uMinIdx = i;
1718	uint64_t uMinVal = RawDescriptor.pPartDescs[i].uStart;
1719	for (unsigned j = i + 1; j < RawDescriptor.cPartDescs; j++)
1720	{
1721	if (RawDescriptor.pPartDescs[j].uStart < uMinVal)
1722	{
1723	uMinIdx = j;
1724	uMinVal = RawDescriptor.pPartDescs[j].uStart;
1725	}
1726	}
1727	if (uMinIdx != i)
1728	{
1729	/* Swap entries at index i and uMinIdx. */
1730	VBOXHDDRAWPARTDESC tmp;
1731	memcpy(&tmp, &RawDescriptor.pPartDescs[i], sizeof(tmp));
1732	memcpy(&RawDescriptor.pPartDescs[i], &RawDescriptor.pPartDescs[uMinIdx], sizeof(tmp));
1733	memcpy(&RawDescriptor.pPartDescs[uMinIdx], &tmp, sizeof(tmp));
1734	}
1735	}
1736
1737	/* Have a second go at MBR/EPT, GPT area clipping. Now that the data areas
1738	* are sorted this is much easier to get 100% right. */
1739	//for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++)
1740	for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++)
1741	{
1742	if (RawDescriptor.pPartDescs[i].pvPartitionData)
1743	{
1744	RawDescriptor.pPartDescs[i].cbData = RT_MIN(RawDescriptor.pPartDescs[i+1].uStart - RawDescriptor.pPartDescs[i].uStart, RawDescriptor.pPartDescs[i].cbData);
1745	if (!RawDescriptor.pPartDescs[i].cbData)
1746	{
1747	if (RawDescriptor.uPartitioningType == MBR)
1748	{
1749	RTMsgError("MBR/EPT overlaps with data area");
1750	vrc = VERR_INVALID_PARAMETER;
1751	goto out;
1752	}
1753	else
1754	{
1755	if (RawDescriptor.cPartDescs != i+1)
1756	{
1757	RTMsgError("GPT overlaps with data area");
1758	vrc = VERR_INVALID_PARAMETER;
1759	goto out;
1760	}
1761	}
1762	}
1763	}
1764	}
1765	}
1766
1767	RTFileClose(hRawFile);
1768
1769	#ifdef DEBUG_klaus
1770	if (!(RawDescriptor.uFlags & VBOXHDDRAW_DISK))
1771	{
1772	RTPrintf("# start length startoffset partdataptr device\n");
1773	for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++)
1774	{
1775	RTPrintf("%2u %14RU64 %14RU64 %14RU64 %#18p %s\n", i,
1776	RawDescriptor.pPartDescs[i].uStart,
1777	RawDescriptor.pPartDescs[i].cbData,
1778	RawDescriptor.pPartDescs[i].uStartOffset,
1779	RawDescriptor.pPartDescs[i].pvPartitionData,
1780	RawDescriptor.pPartDescs[i].pszRawDevice);
1781	}
1782	}
1783	#endif
1784
1785	VDINTERFACEERROR vdInterfaceError;
1786	vdInterfaceError.pfnError = handleVDError;
1787	vdInterfaceError.pfnMessage = handleVDMessage;
1788
1789	rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1790	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
1791	AssertRC(vrc);
1792
1793	vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); /* Raw VMDK's are harddisk only. */
1794	if (RT_FAILURE(vrc))
1795	{
1796	RTMsgError("Cannot create the virtual disk container: %Rrc", vrc);
1797	goto out;
1798	}
1799
1800	Assert(RT_MIN(cbSize / 512 / 16 / 63, 16383) -
1801	(unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383) == 0);
1802	VDGEOMETRY PCHS, LCHS;
1803	PCHS.cCylinders = (unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383);
1804	PCHS.cHeads = 16;
1805	PCHS.cSectors = 63;
1806	LCHS.cCylinders = 0;
1807	LCHS.cHeads = 0;
1808	LCHS.cSectors = 0;
1809	vrc = VDCreateBase(pDisk, "VMDK", filename.c_str(), cbSize,
1810	VD_IMAGE_FLAGS_FIXED \| VD_VMDK_IMAGE_FLAGS_RAWDISK,
1811	(char *)&RawDescriptor, &PCHS, &LCHS, NULL,
1812	VD_OPEN_FLAGS_NORMAL, NULL, NULL);
1813	if (RT_FAILURE(vrc))
1814	{
1815	RTMsgError("Cannot create the raw disk VMDK: %Rrc", vrc);
1816	goto out;
1817	}
1818	RTPrintf("RAW host disk access VMDK file %s created successfully.\n", filename.c_str());
1819
1820	VDCloseAll(pDisk);
1821
1822	/* Clean up allocated memory etc. */
1823	if (pszPartitions)
1824	{
1825	for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++)
1826	{
1827	/* Free memory allocated for relative device name. */
1828	if (fRelative && RawDescriptor.pPartDescs[i].pszRawDevice)
1829	RTStrFree((char )(void )RawDescriptor.pPartDescs[i].pszRawDevice);
1830	if (RawDescriptor.pPartDescs[i].pvPartitionData)
1831	RTMemFree((void *)RawDescriptor.pPartDescs[i].pvPartitionData);
1832	}
1833	if (RawDescriptor.pPartDescs)
1834	RTMemFree(RawDescriptor.pPartDescs);
1835	}
1836
1837	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1838
1839	out:
1840	RTMsgError("The raw disk vmdk file was not created");
1841	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1842	}
1843
1844	static RTEXITCODE CmdRenameVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1845	{
1846	Utf8Str src;
1847	Utf8Str dst;
1848	/* Parse the arguments. */
1849	for (int i = 0; i < argc; i++)
1850	{
1851	if (strcmp(argv[i], "-from") == 0)
1852	{
1853	if (argc <= i + 1)
1854	{
1855	return errorArgument("Missing argument to '%s'", argv[i]);
1856	}
1857	i++;
1858	src = argv[i];
1859	}
1860	else if (strcmp(argv[i], "-to") == 0)
1861	{
1862	if (argc <= i + 1)
1863	{
1864	return errorArgument("Missing argument to '%s'", argv[i]);
1865	}
1866	i++;
1867	dst = argv[i];
1868	}
1869	else
1870	{
1871	return errorSyntax(USAGE_RENAMEVMDK, "Invalid parameter '%s'", argv[i]);
1872	}
1873	}
1874
1875	if (src.isEmpty())
1876	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -from missing");
1877	if (dst.isEmpty())
1878	return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -to missing");
1879
1880	PVBOXHDD pDisk = NULL;
1881
1882	PVDINTERFACE pVDIfs = NULL;
1883	VDINTERFACEERROR vdInterfaceError;
1884	vdInterfaceError.pfnError = handleVDError;
1885	vdInterfaceError.pfnMessage = handleVDMessage;
1886
1887	int vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1888	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
1889	AssertRC(vrc);
1890
1891	vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1892	if (RT_FAILURE(vrc))
1893	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", vrc);
1894
1895	vrc = VDOpen(pDisk, "VMDK", src.c_str(), VD_OPEN_FLAGS_NORMAL, NULL);
1896	if (RT_SUCCESS(vrc))
1897	{
1898	vrc = VDCopy(pDisk, 0, pDisk, "VMDK", dst.c_str(), true, 0,
1899	VD_IMAGE_FLAGS_NONE, NULL, VD_OPEN_FLAGS_NORMAL,
1900	NULL, NULL, NULL);
1901	if (RT_FAILURE(vrc))
1902	RTMsgError("Cannot rename the image: %Rrc", vrc);
1903	}
1904	else
1905	RTMsgError("Cannot create the source image: %Rrc", vrc);
1906	VDCloseAll(pDisk);
1907	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1908	}
1909
1910	static RTEXITCODE CmdConvertToRaw(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
1911	{
1912	Utf8Str srcformat;
1913	Utf8Str src;
1914	Utf8Str dst;
1915	bool fWriteToStdOut = false;
1916
1917	/* Parse the arguments. */
1918	for (int i = 0; i < argc; i++)
1919	{
1920	if (strcmp(argv[i], "-format") == 0)
1921	{
1922	if (argc <= i + 1)
1923	{
1924	return errorArgument("Missing argument to '%s'", argv[i]);
1925	}
1926	i++;
1927	srcformat = argv[i];
1928	}
1929	else if (src.isEmpty())
1930	{
1931	src = argv[i];
1932	}
1933	else if (dst.isEmpty())
1934	{
1935	dst = argv[i];
1936	#ifdef ENABLE_CONVERT_RAW_TO_STDOUT
1937	if (!strcmp(argv[i], "stdout"))
1938	fWriteToStdOut = true;
1939	#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */
1940	}
1941	else
1942	{
1943	return errorSyntax(USAGE_CONVERTTORAW, "Invalid parameter '%s'", argv[i]);
1944	}
1945	}
1946
1947	if (src.isEmpty())
1948	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory filename parameter missing");
1949	if (dst.isEmpty())
1950	return errorSyntax(USAGE_CONVERTTORAW, "Mandatory outputfile parameter missing");
1951
1952	PVBOXHDD pDisk = NULL;
1953
1954	PVDINTERFACE pVDIfs = NULL;
1955	VDINTERFACEERROR vdInterfaceError;
1956	vdInterfaceError.pfnError = handleVDError;
1957	vdInterfaceError.pfnMessage = handleVDMessage;
1958
1959	int vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
1960	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
1961	AssertRC(vrc);
1962
1963	/** @todo: Support convert to raw for floppy and DVD images too. */
1964	vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk);
1965	if (RT_FAILURE(vrc))
1966	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", vrc);
1967
1968	/* Open raw output file. */
1969	RTFILE outFile;
1970	vrc = VINF_SUCCESS;
1971	if (fWriteToStdOut)
1972	vrc = RTFileFromNative(&outFile, 1);
1973	else
1974	vrc = RTFileOpen(&outFile, dst.c_str(), RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_ALL);
1975	if (RT_FAILURE(vrc))
1976	{
1977	VDCloseAll(pDisk);
1978	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create destination file \"%s\": %Rrc", dst.c_str(), vrc);
1979	}
1980
1981	if (srcformat.isEmpty())
1982	{
1983	char *pszFormat = NULL;
1984	VDTYPE enmType = VDTYPE_INVALID;
1985	vrc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
1986	src.c_str(), &pszFormat, &enmType);
1987	if (RT_FAILURE(vrc) \|\| enmType != VDTYPE_HDD)
1988	{
1989	VDCloseAll(pDisk);
1990	if (!fWriteToStdOut)
1991	{
1992	RTFileClose(outFile);
1993	RTFileDelete(dst.c_str());
1994	}
1995	if (RT_FAILURE(vrc))
1996	RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
1997	else
1998	RTMsgError("Only converting harddisk images is supported");
1999	return RTEXITCODE_FAILURE;
2000	}
2001	srcformat = pszFormat;
2002	RTStrFree(pszFormat);
2003	}
2004	vrc = VDOpen(pDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL);
2005	if (RT_FAILURE(vrc))
2006	{
2007	VDCloseAll(pDisk);
2008	if (!fWriteToStdOut)
2009	{
2010	RTFileClose(outFile);
2011	RTFileDelete(dst.c_str());
2012	}
2013	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the source image: %Rrc", vrc);
2014	}
2015
2016	uint64_t cbSize = VDGetSize(pDisk, VD_LAST_IMAGE);
2017	uint64_t offFile = 0;
2018	#define RAW_BUFFER_SIZE _128K
2019	size_t cbBuf = RAW_BUFFER_SIZE;
2020	void *pvBuf = RTMemAlloc(cbBuf);
2021	if (pvBuf)
2022	{
2023	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
2024	while (offFile < cbSize)
2025	{
2026	size_t cb = (size_t)RT_MIN(cbSize - offFile, cbBuf);
2027	vrc = VDRead(pDisk, offFile, pvBuf, cb);
2028	if (RT_FAILURE(vrc))
2029	break;
2030	vrc = RTFileWrite(outFile, pvBuf, cb, NULL);
2031	if (RT_FAILURE(vrc))
2032	break;
2033	offFile += cb;
2034	}
2035	RTMemFree(pvBuf);
2036	if (RT_FAILURE(vrc))
2037	{
2038	VDCloseAll(pDisk);
2039	if (!fWriteToStdOut)
2040	{
2041	RTFileClose(outFile);
2042	RTFileDelete(dst.c_str());
2043	}
2044	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot copy image data: %Rrc", vrc);
2045	}
2046	}
2047	else
2048	{
2049	vrc = VERR_NO_MEMORY;
2050	VDCloseAll(pDisk);
2051	if (!fWriteToStdOut)
2052	{
2053	RTFileClose(outFile);
2054	RTFileDelete(dst.c_str());
2055	}
2056	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory allocating read buffer");
2057	}
2058
2059	if (!fWriteToStdOut)
2060	RTFileClose(outFile);
2061	VDCloseAll(pDisk);
2062	return RTEXITCODE_SUCCESS;
2063	}
2064
2065	static RTEXITCODE CmdConvertHardDisk(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
2066	{
2067	Utf8Str srcformat;
2068	Utf8Str dstformat;
2069	Utf8Str src;
2070	Utf8Str dst;
2071	int vrc;
2072	PVBOXHDD pSrcDisk = NULL;
2073	PVBOXHDD pDstDisk = NULL;
2074	VDTYPE enmSrcType = VDTYPE_INVALID;
2075
2076	/* Parse the arguments. */
2077	for (int i = 0; i < argc; i++)
2078	{
2079	if (strcmp(argv[i], "-srcformat") == 0)
2080	{
2081	if (argc <= i + 1)
2082	{
2083	return errorArgument("Missing argument to '%s'", argv[i]);
2084	}
2085	i++;
2086	srcformat = argv[i];
2087	}
2088	else if (strcmp(argv[i], "-dstformat") == 0)
2089	{
2090	if (argc <= i + 1)
2091	{
2092	return errorArgument("Missing argument to '%s'", argv[i]);
2093	}
2094	i++;
2095	dstformat = argv[i];
2096	}
2097	else if (src.isEmpty())
2098	{
2099	src = argv[i];
2100	}
2101	else if (dst.isEmpty())
2102	{
2103	dst = argv[i];
2104	}
2105	else
2106	{
2107	return errorSyntax(USAGE_CONVERTHD, "Invalid parameter '%s'", argv[i]);
2108	}
2109	}
2110
2111	if (src.isEmpty())
2112	return errorSyntax(USAGE_CONVERTHD, "Mandatory input image parameter missing");
2113	if (dst.isEmpty())
2114	return errorSyntax(USAGE_CONVERTHD, "Mandatory output image parameter missing");
2115
2116
2117	PVDINTERFACE pVDIfs = NULL;
2118	VDINTERFACEERROR vdInterfaceError;
2119	vdInterfaceError.pfnError = handleVDError;
2120	vdInterfaceError.pfnMessage = handleVDMessage;
2121
2122	vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
2123	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
2124	AssertRC(vrc);
2125
2126	do
2127	{
2128	/* Try to determine input image format */
2129	if (srcformat.isEmpty())
2130	{
2131	char *pszFormat = NULL;
2132	vrc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
2133	src.c_str(), &pszFormat, &enmSrcType);
2134	if (RT_FAILURE(vrc))
2135	{
2136	RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
2137	break;
2138	}
2139	srcformat = pszFormat;
2140	RTStrFree(pszFormat);
2141	}
2142
2143	vrc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk);
2144	if (RT_FAILURE(vrc))
2145	{
2146	RTMsgError("Cannot create the source virtual disk container: %Rrc", vrc);
2147	break;
2148	}
2149
2150	/* Open the input image */
2151	vrc = VDOpen(pSrcDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL);
2152	if (RT_FAILURE(vrc))
2153	{
2154	RTMsgError("Cannot open the source image: %Rrc", vrc);
2155	break;
2156	}
2157
2158	/* Output format defaults to VDI */
2159	if (dstformat.isEmpty())
2160	dstformat = "VDI";
2161
2162	vrc = VDCreate(pVDIfs, enmSrcType, &pDstDisk);
2163	if (RT_FAILURE(vrc))
2164	{
2165	RTMsgError("Cannot create the destination virtual disk container: %Rrc", vrc);
2166	break;
2167	}
2168
2169	uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE);
2170	RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", src.c_str(), cbSize, (cbSize + _1M - 1) / _1M);
2171
2172	/* Create the output image */
2173	vrc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, dstformat.c_str(),
2174	dst.c_str(), false, 0, VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED,
2175	NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL, NULL);
2176	if (RT_FAILURE(vrc))
2177	{
2178	RTMsgError("Cannot copy the image: %Rrc", vrc);
2179	break;
2180	}
2181	}
2182	while (0);
2183	if (pDstDisk)
2184	VDCloseAll(pDstDisk);
2185	if (pSrcDisk)
2186	VDCloseAll(pSrcDisk);
2187
2188	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2189	}
2190
2191	/**
2192	* Tries to repair a corrupted hard disk image.
2193	*
2194	* @returns VBox status code
2195	*/
2196	static RTEXITCODE CmdRepairHardDisk(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
2197	{
2198	Utf8Str image;
2199	Utf8Str format;
2200	int vrc;
2201	bool fDryRun = false;
2202	PVBOXHDD pDisk = NULL;
2203
2204	/* Parse the arguments. */
2205	for (int i = 0; i < argc; i++)
2206	{
2207	if (strcmp(argv[i], "-dry-run") == 0)
2208	{
2209	fDryRun = true;
2210	}
2211	else if (strcmp(argv[i], "-format") == 0)
2212	{
2213	if (argc <= i + 1)
2214	{
2215	return errorArgument("Missing argument to '%s'", argv[i]);
2216	}
2217	i++;
2218	format = argv[i];
2219	}
2220	else if (image.isEmpty())
2221	{
2222	image = argv[i];
2223	}
2224	else
2225	{
2226	return errorSyntax(USAGE_REPAIRHD, "Invalid parameter '%s'", argv[i]);
2227	}
2228	}
2229
2230	if (image.isEmpty())
2231	return errorSyntax(USAGE_REPAIRHD, "Mandatory input image parameter missing");
2232
2233	PVDINTERFACE pVDIfs = NULL;
2234	VDINTERFACEERROR vdInterfaceError;
2235	vdInterfaceError.pfnError = handleVDError;
2236	vdInterfaceError.pfnMessage = handleVDMessage;
2237
2238	vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR,
2239	NULL, sizeof(VDINTERFACEERROR), &pVDIfs);
2240	AssertRC(vrc);
2241
2242	do
2243	{
2244	/* Try to determine input image format */
2245	if (format.isEmpty())
2246	{
2247	char *pszFormat = NULL;
2248	VDTYPE enmSrcType = VDTYPE_INVALID;
2249
2250	vrc = VDGetFormat(NULL /* pVDIfsDisk /, NULL / pVDIfsImage */,
2251	image.c_str(), &pszFormat, &enmSrcType);
2252	if (RT_FAILURE(vrc) && (vrc != VERR_VD_IMAGE_CORRUPTED))
2253	{
2254	RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc);
2255	break;
2256	}
2257	format = pszFormat;
2258	RTStrFree(pszFormat);
2259	}
2260
2261	uint32_t fFlags = 0;
2262	if (fDryRun)
2263	fFlags \|= VD_REPAIR_DRY_RUN;
2264
2265	vrc = VDRepair(pVDIfs, NULL, image.c_str(), format.c_str(), fFlags);
2266	}
2267	while (0);
2268
2269	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2270	}
2271
2272	/**
2273	* Unloads the necessary driver.
2274	*
2275	* @returns VBox status code
2276	*/
2277	static RTEXITCODE CmdModUninstall(void)
2278	{
2279	int rc = SUPR3Uninstall();
2280	if (RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED)
2281	return RTEXITCODE_SUCCESS;
2282	return RTEXITCODE_FAILURE;
2283	}
2284
2285	/**
2286	* Loads the necessary driver.
2287	*
2288	* @returns VBox status code
2289	*/
2290	static RTEXITCODE CmdModInstall(void)
2291	{
2292	int rc = SUPR3Install();
2293	if (RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED)
2294	return RTEXITCODE_SUCCESS;
2295	return RTEXITCODE_FAILURE;
2296	}
2297
2298	static RTEXITCODE CmdDebugLog(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
2299	{
2300	/*
2301	* The first parameter is the name or UUID of a VM with a direct session
2302	* that we wish to open.
2303	*/
2304	if (argc < 1)
2305	return errorSyntax(USAGE_DEBUGLOG, "Missing VM name/UUID");
2306
2307	ComPtr<IMachine> ptrMachine;
2308	HRESULT rc;
2309	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
2310	ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
2311
2312	CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), RTEXITCODE_FAILURE);
2313
2314	/*
2315	* Get the debugger interface.
2316	*/
2317	ComPtr<IConsole> ptrConsole;
2318	CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
2319
2320	ComPtr<IMachineDebugger> ptrDebugger;
2321	CHECK_ERROR_RET(ptrConsole, COMGETTER(Debugger)(ptrDebugger.asOutParam()), RTEXITCODE_FAILURE);
2322
2323	/*
2324	* Parse the command.
2325	*/
2326	bool fEnablePresent = false;
2327	bool fEnable = false;
2328	bool fFlagsPresent = false;
2329	RTCString strFlags;
2330	bool fGroupsPresent = false;
2331	RTCString strGroups;
2332	bool fDestsPresent = false;
2333	RTCString strDests;
2334
2335	static const RTGETOPTDEF s_aOptions[] =
2336	{
2337	{ "--disable", 'E', RTGETOPT_REQ_NOTHING },
2338	{ "--enable", 'e', RTGETOPT_REQ_NOTHING },
2339	{ "--flags", 'f', RTGETOPT_REQ_STRING },
2340	{ "--groups", 'g', RTGETOPT_REQ_STRING },
2341	{ "--destinations", 'd', RTGETOPT_REQ_STRING }
2342	};
2343
2344	int ch;
2345	RTGETOPTUNION ValueUnion;
2346	RTGETOPTSTATE GetState;
2347	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
2348	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2349	{
2350	switch (ch)
2351	{
2352	case 'e':
2353	fEnablePresent = true;
2354	fEnable = true;
2355	break;
2356
2357	case 'E':
2358	fEnablePresent = true;
2359	fEnable = false;
2360	break;
2361
2362	case 'f':
2363	fFlagsPresent = true;
2364	if (*ValueUnion.psz)
2365	{
2366	if (strFlags.isNotEmpty())
2367	strFlags.append(' ');
2368	strFlags.append(ValueUnion.psz);
2369	}
2370	break;
2371
2372	case 'g':
2373	fGroupsPresent = true;
2374	if (*ValueUnion.psz)
2375	{
2376	if (strGroups.isNotEmpty())
2377	strGroups.append(' ');
2378	strGroups.append(ValueUnion.psz);
2379	}
2380	break;
2381
2382	case 'd':
2383	fDestsPresent = true;
2384	if (*ValueUnion.psz)
2385	{
2386	if (strDests.isNotEmpty())
2387	strDests.append(' ');
2388	strDests.append(ValueUnion.psz);
2389	}
2390	break;
2391
2392	default:
2393	return errorGetOpt(USAGE_DEBUGLOG, ch, &ValueUnion);
2394	}
2395	}
2396
2397	/*
2398	* Do the job.
2399	*/
2400	if (fEnablePresent && !fEnable)
2401	CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(FALSE), RTEXITCODE_FAILURE);
2402
2403	/** @todo flags, groups destination. */
2404	if (fFlagsPresent \|\| fGroupsPresent \|\| fDestsPresent)
2405	RTMsgWarning("One or more of the requested features are not implemented! Feel free to do this.");
2406
2407	if (fEnablePresent && fEnable)
2408	CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(TRUE), RTEXITCODE_FAILURE);
2409	return RTEXITCODE_SUCCESS;
2410	}
2411
2412	/**
2413	* Generate a SHA-256 password hash
2414	*/
2415	static RTEXITCODE CmdGeneratePasswordHash(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
2416	{
2417	/* one parameter, the password to hash */
2418	if (argc != 1)
2419	return errorSyntax(USAGE_PASSWORDHASH, "password to hash required");
2420
2421	uint8_t abDigest[RTSHA256_HASH_SIZE];
2422	RTSha256(argv[0], strlen(argv[0]), abDigest);
2423	char pszDigest[RTSHA256_DIGEST_LEN + 1];
2424	RTSha256ToString(abDigest, pszDigest, sizeof(pszDigest));
2425	RTPrintf("Password hash: %s\n", pszDigest);
2426
2427	return RTEXITCODE_SUCCESS;
2428	}
2429
2430	/**
2431	* Print internal guest statistics or
2432	* set internal guest statistics update interval if specified
2433	*/
2434	static RTEXITCODE CmdGuestStats(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
2435	{
2436	/* one parameter, guest name */
2437	if (argc < 1)
2438	return errorSyntax(USAGE_GUESTSTATS, "Missing VM name/UUID");
2439
2440	/*
2441	* Parse the command.
2442	*/
2443	ULONG aUpdateInterval = 0;
2444
2445	static const RTGETOPTDEF s_aOptions[] =
2446	{
2447	{ "--interval", 'i', RTGETOPT_REQ_UINT32 }
2448	};
2449
2450	int ch;
2451	RTGETOPTUNION ValueUnion;
2452	RTGETOPTSTATE GetState;
2453	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
2454	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2455	{
2456	switch (ch)
2457	{
2458	case 'i':
2459	aUpdateInterval = ValueUnion.u32;
2460	break;
2461
2462	default:
2463	return errorGetOpt(USAGE_GUESTSTATS, ch, &ValueUnion);
2464	}
2465	}
2466
2467	if (argc > 1 && aUpdateInterval == 0)
2468	return errorSyntax(USAGE_GUESTSTATS, "Invalid update interval specified");
2469
2470	RTPrintf("argc=%d interval=%u\n", argc, aUpdateInterval);
2471
2472	ComPtr<IMachine> ptrMachine;
2473	HRESULT rc;
2474	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(),
2475	ptrMachine.asOutParam()), RTEXITCODE_FAILURE);
2476
2477	CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), RTEXITCODE_FAILURE);
2478
2479	/*
2480	* Get the guest interface.
2481	*/
2482	ComPtr<IConsole> ptrConsole;
2483	CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE);
2484
2485	ComPtr<IGuest> ptrGuest;
2486	CHECK_ERROR_RET(ptrConsole, COMGETTER(Guest)(ptrGuest.asOutParam()), RTEXITCODE_FAILURE);
2487
2488	if (aUpdateInterval)
2489	CHECK_ERROR_RET(ptrGuest, COMSETTER(StatisticsUpdateInterval)(aUpdateInterval), RTEXITCODE_FAILURE);
2490	else
2491	{
2492	ULONG mCpuUser, mCpuKernel, mCpuIdle;
2493	ULONG mMemTotal, mMemFree, mMemBalloon, mMemShared, mMemCache, mPageTotal;
2494	ULONG ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal;
2495
2496	CHECK_ERROR_RET(ptrGuest, InternalGetStatistics(&mCpuUser, &mCpuKernel, &mCpuIdle,
2497	&mMemTotal, &mMemFree, &mMemBalloon, &mMemShared, &mMemCache,
2498	&mPageTotal, &ulMemAllocTotal, &ulMemFreeTotal,
2499	&ulMemBalloonTotal, &ulMemSharedTotal),
2500	RTEXITCODE_FAILURE);
2501	RTPrintf("mCpuUser=%u mCpuKernel=%u mCpuIdle=%u\n"
2502	"mMemTotal=%u mMemFree=%u mMemBalloon=%u mMemShared=%u mMemCache=%u\n"
2503	"mPageTotal=%u ulMemAllocTotal=%u ulMemFreeTotal=%u ulMemBalloonTotal=%u ulMemSharedTotal=%u\n",
2504	mCpuUser, mCpuKernel, mCpuIdle,
2505	mMemTotal, mMemFree, mMemBalloon, mMemShared, mMemCache,
2506	mPageTotal, ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal);
2507
2508	}
2509
2510	return RTEXITCODE_SUCCESS;
2511	}
2512
2513
2514	/**
2515	* Wrapper for handling internal commands
2516	*/
2517	RTEXITCODE handleInternalCommands(HandlerArg *a)
2518	{
2519	g_fInternalMode = true;
2520
2521	/* at least a command is required */
2522	if (a->argc < 1)
2523	return errorSyntax(USAGE_ALL, "Command missing");
2524
2525	/*
2526	* The 'string switch' on command name.
2527	*/
2528	const char *pszCmd = a->argv[0];
2529	if (!strcmp(pszCmd, "loadmap"))
2530	return CmdLoadMap(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2531	if (!strcmp(pszCmd, "loadsyms"))
2532	return CmdLoadSyms(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2533	//if (!strcmp(pszCmd, "unloadsyms"))
2534	// return CmdUnloadSyms(argc - 1, &a->argv[1]);
2535	if (!strcmp(pszCmd, "sethduuid") \|\| !strcmp(pszCmd, "sethdparentuuid"))
2536	return CmdSetHDUUID(a->argc, &a->argv[0], a->virtualBox, a->session);
2537	if (!strcmp(pszCmd, "dumphdinfo"))
2538	return CmdDumpHDInfo(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2539	if (!strcmp(pszCmd, "listpartitions"))
2540	return CmdListPartitions(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2541	if (!strcmp(pszCmd, "createrawvmdk"))
2542	return CmdCreateRawVMDK(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2543	if (!strcmp(pszCmd, "renamevmdk"))
2544	return CmdRenameVMDK(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2545	if (!strcmp(pszCmd, "converttoraw"))
2546	return CmdConvertToRaw(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2547	if (!strcmp(pszCmd, "converthd"))
2548	return CmdConvertHardDisk(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2549	if (!strcmp(pszCmd, "modinstall"))
2550	return CmdModInstall();
2551	if (!strcmp(pszCmd, "moduninstall"))
2552	return CmdModUninstall();
2553	if (!strcmp(pszCmd, "debuglog"))
2554	return CmdDebugLog(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2555	if (!strcmp(pszCmd, "passwordhash"))
2556	return CmdGeneratePasswordHash(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2557	if (!strcmp(pszCmd, "gueststats"))
2558	return CmdGuestStats(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2559	if (!strcmp(pszCmd, "repairhd"))
2560	return CmdRepairHardDisk(a->argc - 1, &a->argv[1], a->virtualBox, a->session);
2561
2562	/* default: */
2563	return errorSyntax(USAGE_ALL, "Invalid command '%s'", a->argv[0]);
2564	}
2565

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

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

Download in other formats: