VirtualBox

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

Last change on this file since 33595 was 33595, checked in by vboxsync, 14 years ago

src/*: more spelling fixes (logging), 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 33595 2010-10-29 10:35:00Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'internalcommands' command.
4 *
5 * VBoxInternalManage used to be a second CLI for doing special tricks,
6 * not intended for general usage, only for assisting VBox developers.
7 * It is now integrated into VBoxManage.
8 */
9
10/*
11 * Copyright (C) 2006-2010 Oracle Corporation
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 */
21
22
23
24/*******************************************************************************
25* Header Files *
26*******************************************************************************/
27#include <VBox/com/com.h>
28#include <VBox/com/string.h>
29#include <VBox/com/Guid.h>
30#include <VBox/com/ErrorInfo.h>
31#include <VBox/com/errorprint.h>
32
33#include <VBox/com/VirtualBox.h>
34
35#include <VBox/vd.h>
36#include <VBox/sup.h>
37#include <VBox/err.h>
38#include <VBox/log.h>
39
40#include <iprt/file.h>
41#include <iprt/getopt.h>
42#include <iprt/stream.h>
43#include <iprt/string.h>
44#include <iprt/uuid.h>
45#include <iprt/sha.h>
46
47#include "VBoxManage.h"
48
49/* Includes for the raw disk stuff. */
50#ifdef RT_OS_WINDOWS
51# include <windows.h>
52# include <winioctl.h>
53#elif defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) \
54 || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD)
55# include <errno.h>
56# include <sys/ioctl.h>
57# include <sys/types.h>
58# include <sys/stat.h>
59# include <fcntl.h>
60# include <unistd.h>
61#endif
62#ifdef RT_OS_LINUX
63# include <sys/utsname.h>
64# include <linux/hdreg.h>
65# include <linux/fs.h>
66# include <stdlib.h> /* atoi() */
67#endif /* RT_OS_LINUX */
68#ifdef RT_OS_DARWIN
69# include <sys/disk.h>
70#endif /* RT_OS_DARWIN */
71#ifdef RT_OS_SOLARIS
72# include <stropts.h>
73# include <sys/dkio.h>
74# include <sys/vtoc.h>
75#endif /* RT_OS_SOLARIS */
76#ifdef RT_OS_FREEBSD
77# include <sys/disk.h>
78#endif /* RT_OS_FREEBSD */
79
80using 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
92typedef 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
120typedef struct HOSTPARTITIONS
121{
122 unsigned cPartitions;
123 HOSTPARTITION aPartitions[HOSTPARTITION_MAX];
124} HOSTPARTITIONS, *PHOSTPARTITIONS;
125
126/** flag whether we're in internal mode */
127bool g_fInternalMode;
128
129/**
130 * Print the usage info.
131 */
132void 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 necessary 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 */
262static 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 */
320static 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 */
384static 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 */
406static 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 */
424static 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 */
435static 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
508static 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
514static int handleVDMessage(void *pvUser, const char *pszFormat, va_list va)
515{
516 NOREF(pvUser);
517 return RTPrintfV(pszFormat, va);
518}
519
520static 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
610static 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
665static 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
836static 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("Cannot 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
897static 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
913static 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
1492out:
1493 RTMsgError("The raw disk vmdk file was not created");
1494 return RT_SUCCESS(vrc) ? 0 : 1;
1495}
1496
1497static 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
1575static 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
1739static 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 */
1873int 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 */
1890int 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
1902int 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 */
2019int 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 */
2037int 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.

© 2024 Oracle
Contact – Privacy/Do Not Sell My Info – Terms of Use