/* $Id: VBoxInternalManage.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */ /** @file * VBoxManage - The 'internalcommands' command. * * VBoxInternalManage used to be a second CLI for doing special tricks, * not intended for general usage, only for assisting VBox developers. * It is now integrated into VBoxManage. */ /* * Copyright (C) 2006-2023 Oracle and/or its affiliates. * * This file is part of VirtualBox base platform packages, as * available from https://www.virtualbox.org. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation, in version 3 of the * License. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see . * * SPDX-License-Identifier: GPL-3.0-only */ /********************************************************************************************************************************* * Header Files * *********************************************************************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "VBoxManage.h" /* Includes for the raw disk stuff. */ #ifdef RT_OS_WINDOWS # include # include #elif defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) \ || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD) # include # include # include # include # include # include #endif #ifdef RT_OS_LINUX # include # include # include # include /* atoi() */ #endif /* RT_OS_LINUX */ #ifdef RT_OS_DARWIN # include #endif /* RT_OS_DARWIN */ #ifdef RT_OS_SOLARIS # include # include # include #endif /* RT_OS_SOLARIS */ #ifdef RT_OS_FREEBSD # include #endif /* RT_OS_FREEBSD */ using namespace com; /** Macro for checking whether a partition is of extended type or not. */ #define PARTTYPE_IS_EXTENDED(x) ((x) == 0x05 || (x) == 0x0f || (x) == 0x85) /** Maximum number of partitions we can deal with. * Ridiculously large number, but the memory consumption is rather low so who * cares about never using most entries. */ #define HOSTPARTITION_MAX 100 DECLARE_TRANSLATION_CONTEXT(Internal); typedef struct HOSTPARTITION { /** partition number */ unsigned uIndex; /** partition number (internal only, windows specific numbering) */ unsigned uIndexWin; /** partition type */ unsigned uType; /** CHS/cylinder of the first sector */ unsigned uStartCylinder; /** CHS/head of the first sector */ unsigned uStartHead; /** CHS/head of the first sector */ unsigned uStartSector; /** CHS/cylinder of the last sector */ unsigned uEndCylinder; /** CHS/head of the last sector */ unsigned uEndHead; /** CHS/sector of the last sector */ unsigned uEndSector; /** start sector of this partition relative to the beginning of the hard * disk or relative to the beginning of the extended partition table */ uint64_t uStart; /** numer of sectors of the partition */ uint64_t uSize; /** start sector of this partition _table_ */ uint64_t uPartDataStart; /** numer of sectors of this partition _table_ */ uint64_t cPartDataSectors; } HOSTPARTITION, *PHOSTPARTITION; typedef struct HOSTPARTITIONS { /** partitioning type - MBR or GPT */ VDISKPARTTYPE uPartitioningType; unsigned cPartitions; HOSTPARTITION aPartitions[HOSTPARTITION_MAX]; } HOSTPARTITIONS, *PHOSTPARTITIONS; /** @name Syntax diagram category, i.e. the command. * @{ */ typedef enum { USAGE_INVALID = 0, USAGE_I_LOADSYMS, USAGE_I_LOADMAP, USAGE_I_SETHDUUID, USAGE_I_LISTPARTITIONS, USAGE_I_CREATERAWVMDK, USAGE_I_MODINSTALL, USAGE_I_MODUNINSTALL, USAGE_I_RENAMEVMDK, USAGE_I_CONVERTTORAW, USAGE_I_CONVERTHD, USAGE_I_DUMPHDINFO, USAGE_I_DEBUGLOG, USAGE_I_SETHDPARENTUUID, USAGE_I_PASSWORDHASH, USAGE_I_GUESTSTATS, USAGE_I_REPAIRHD, USAGE_I_ALL } USAGECATEGORY; /** @} */ /** * Print the usage info. */ static void printUsageInternal(USAGECATEGORY enmCommand, PRTSTREAM pStrm) { Assert(enmCommand != USAGE_INVALID); RTStrmPrintf(pStrm, Internal::tr( "Usage: VBoxManage internalcommands [command arguments]\n" "\n" "Commands:\n" "\n" "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s" "WARNING: This is a development tool and should only be used to analyse\n" " problems. It is completely unsupported and will change in\n" " incompatible ways without warning.\n"), (enmCommand == USAGE_I_LOADMAP || enmCommand == USAGE_I_ALL) ? Internal::tr( " loadmap
[module] [subtrahend] [segment]\n" " This will instruct DBGF to load the given map file\n" " during initialization. (See also loadmap in the debugger.)\n" "\n") : "", (enmCommand == USAGE_I_LOADSYMS || enmCommand == USAGE_I_ALL) ? Internal::tr( " loadsyms [delta] [module] [module address]\n" " This will instruct DBGF to load the given symbol file\n" " during initialization.\n" "\n") : "", (enmCommand == USAGE_I_SETHDUUID || enmCommand == USAGE_I_ALL) ? Internal::tr( " sethduuid []\n" " Assigns a new UUID to the given image file. This way, multiple copies\n" " of a container can be registered.\n" "\n") : "", (enmCommand == USAGE_I_SETHDPARENTUUID || enmCommand == USAGE_I_ALL) ? Internal::tr( " sethdparentuuid \n" " Assigns a new parent UUID to the given image file.\n" "\n") : "", (enmCommand == USAGE_I_DUMPHDINFO || enmCommand == USAGE_I_ALL) ? Internal::tr( " dumphdinfo \n" " Prints information about the image at the given location.\n" "\n") : "", (enmCommand == USAGE_I_LISTPARTITIONS || enmCommand == USAGE_I_ALL) ? Internal::tr( " listpartitions -rawdisk \n" " Lists all partitions on .\n" "\n") : "", (enmCommand == USAGE_I_CREATERAWVMDK || enmCommand == USAGE_I_ALL) ? Internal::tr( " createrawvmdk --filename --rawdisk \n" " [--partitions [--mbr ] ]\n" " [--relative]\n" " Creates a new VMDK image which gives direct access to a physical hard\n" " disk on the host. The entire disk can be presented to the guest or\n" " just specific partitions specified using the --partitions parameter.\n" " If access to individual partitions is granted, then the --mbr parameter\n" " can be used to specify an alternative Master Boot Record (MBR) (note\n" " that the partitioning information in the MBR file is ignored). The\n" " format of the diskname argument for the --rawdisk parameter varies by\n" " platform but can be determined using the command:\n" " VBoxManage list hostdrives\n" " The output lists the available drives and their partitions along with\n" " their partition types and sizes.\n" " On Linux, FreeBSD, and Windows hosts the --relative parameter creates a\n" " VMDK image file which references the specified individual partitions\n" " directly instead of referencing the partitions by their offset from\n" " the start of the physical disk.\n" "\n" " Nota Bene: The 'createrawvdk' subcommand is deprecated. The equivalent\n" " functionality is available using the 'VBoxManage createmedium' command\n" " and should be used instead. See 'VBoxManage help createmedium' for\n" " details.\n" "\n") : "", (enmCommand == USAGE_I_RENAMEVMDK || enmCommand == USAGE_I_ALL) ? Internal::tr( " renamevmdk -from -to \n" " Renames an existing VMDK image, including the base file and all its extents.\n" "\n") : "", (enmCommand == USAGE_I_CONVERTTORAW || enmCommand == USAGE_I_ALL) #ifdef ENABLE_CONVERT_RAW_TO_STDOUT ? Internal::tr( " converttoraw [-format ] |stdout" "\n" " Convert image to raw, writing to file or stdout.\n" "\n") #else ? Internal::tr( " converttoraw [-format ] " "\n" " Convert image to raw, writing to file.\n" "\n") #endif : "", (enmCommand == USAGE_I_CONVERTHD || enmCommand == USAGE_I_ALL) ? Internal::tr( " converthd [-srcformat VDI|VMDK|VHD|RAW]\n" " [-dstformat VDI|VMDK|VHD|RAW]\n" " \n" " converts hard disk images between formats\n" "\n") : "", (enmCommand == USAGE_I_REPAIRHD || enmCommand == USAGE_I_ALL) ? Internal::tr( " repairhd [-dry-run]\n" " [-format VDI|VMDK|VHD|...]\n" " \n" " Tries to repair corrupted disk images\n" "\n") : "", #ifdef RT_OS_WINDOWS (enmCommand == USAGE_I_MODINSTALL || enmCommand == USAGE_I_ALL) ? Internal::tr( " modinstall\n" " Installs the necessary driver for the host OS\n" "\n") : "", (enmCommand == USAGE_I_MODUNINSTALL || enmCommand == USAGE_I_ALL) ? Internal::tr( " moduninstall\n" " Deinstalls the driver\n" "\n") : "", #else "", "", #endif (enmCommand == USAGE_I_DEBUGLOG || enmCommand == USAGE_I_ALL) ? Internal::tr( " debuglog [--enable|--disable] [--flags todo]\n" " [--groups todo] [--destinations todo]\n" " Controls debug logging.\n" "\n") : "", (enmCommand == USAGE_I_PASSWORDHASH || enmCommand == USAGE_I_ALL) ? Internal::tr( " passwordhash \n" " Generates a password hash.\n" "\n") : "", (enmCommand == USAGE_I_GUESTSTATS || enmCommand == USAGE_I_ALL) ? Internal::tr( " gueststats [--interval ]\n" " Obtains and prints internal guest statistics.\n" " Sets the update interval if specified.\n" "\n") : "" ); } /** * Print a usage synopsis and the syntax error message. * @returns RTEXITCODE_SYNTAX. */ static RTEXITCODE errorSyntaxInternal(USAGECATEGORY enmCommand, const char *pszFormat, ...) { va_list args; showLogo(g_pStdErr); // show logo even if suppressed printUsageInternal(enmCommand, g_pStdErr); va_start(args, pszFormat); RTStrmPrintf(g_pStdErr, Internal::tr("\nSyntax error: %N\n"), pszFormat, &args); va_end(args); return RTEXITCODE_SYNTAX; } /** * errorSyntaxInternal for RTGetOpt users. * * @returns RTEXITCODE_SYNTAX. * * @param enmCommand The command. * @param vrc The RTGetOpt return code. * @param pValueUnion The value union. */ static RTEXITCODE errorGetOptInternal(USAGECATEGORY enmCommand, int vrc, union RTGETOPTUNION const *pValueUnion) { /* * Check if it is an unhandled standard option. */ if (vrc == 'V') { RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision()); return RTEXITCODE_SUCCESS; } if (vrc == 'h') { showLogo(g_pStdErr); printUsageInternal(enmCommand, g_pStdOut); return RTEXITCODE_SUCCESS; } /* * General failure. */ showLogo(g_pStdErr); // show logo even if suppressed printUsageInternal(enmCommand, g_pStdErr); if (vrc == VINF_GETOPT_NOT_OPTION) return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid parameter '%s'"), pValueUnion->psz); if (vrc > 0) { if (RT_C_IS_PRINT(vrc)) return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option -%c"), vrc); return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid option case %i"), vrc); } if (vrc == VERR_GETOPT_UNKNOWN_OPTION) return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Unknown option: %s"), pValueUnion->psz); if (vrc == VERR_GETOPT_INVALID_ARGUMENT_FORMAT) return RTMsgErrorExit(RTEXITCODE_SYNTAX, Internal::tr("Invalid argument format: %s"), pValueUnion->psz); if (pValueUnion->pDef) return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%s: %Rrs", pValueUnion->pDef->pszLong, vrc); return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%Rrs", vrc); } /** * Externally visible wrapper around printUsageInternal() to dump the * complete usage text. * * @param pStrm The stream to dump the usage text to. */ DECLHIDDEN(void) printUsageInternalCmds(PRTSTREAM pStrm) { printUsageInternal(USAGE_I_ALL, pStrm); } /** @todo this is no longer necessary, we can enumerate extra data */ /** * Finds a new unique key name. * * I don't think this is 100% race condition proof, but we assumes * the user is not trying to push this point. * * @returns Result from the insert. * @param pMachine The Machine object. * @param pszKeyBase The base key. * @param rKey Reference to the string object in which we will return the key. */ static HRESULT NewUniqueKey(ComPtr pMachine, const char *pszKeyBase, Utf8Str &rKey) { Bstr KeyBase(pszKeyBase); Bstr Keys; HRESULT hrc = pMachine->GetExtraData(KeyBase.raw(), Keys.asOutParam()); if (FAILED(hrc)) return hrc; /* if there are no keys, it's simple. */ if (Keys.isEmpty()) { rKey = "1"; return pMachine->SetExtraData(KeyBase.raw(), Bstr(rKey).raw()); } /* find a unique number - brute force rulez. */ Utf8Str KeysUtf8(Keys); const char *pszKeys = RTStrStripL(KeysUtf8.c_str()); for (unsigned i = 1; i < 1000000; i++) { char szKey[32]; size_t cchKey = RTStrPrintf(szKey, sizeof(szKey), "%#x", i); const char *psz = strstr(pszKeys, szKey); while (psz) { if ( ( psz == pszKeys || psz[-1] == ' ') && ( psz[cchKey] == ' ' || !psz[cchKey]) ) break; psz = strstr(psz + cchKey, szKey); } if (!psz) { rKey = szKey; Utf8StrFmt NewKeysUtf8("%s %s", pszKeys, szKey); return pMachine->SetExtraData(KeyBase.raw(), Bstr(NewKeysUtf8).raw()); } } RTMsgError(Internal::tr("Cannot find unique key for '%s'!"), pszKeyBase); return E_FAIL; } #if 0 /** * Remove a key. * * I don't think this isn't 100% race condition proof, but we assumes * the user is not trying to push this point. * * @returns Result from the insert. * @param pMachine The machine object. * @param pszKeyBase The base key. * @param pszKey The key to remove. */ static HRESULT RemoveKey(ComPtr pMachine, const char *pszKeyBase, const char *pszKey) { Bstr Keys; HRESULT hrc = pMachine->GetExtraData(Bstr(pszKeyBase), Keys.asOutParam()); if (FAILED(hrc)) return hrc; /* if there are no keys, it's simple. */ if (Keys.isEmpty()) return S_OK; char *pszKeys; int vrc = RTUtf16ToUtf8(Keys.raw(), &pszKeys); if (RT_SUCCESS(vrc)) { /* locate it */ size_t cchKey = strlen(pszKey); char *psz = strstr(pszKeys, pszKey); while (psz) { if ( ( psz == pszKeys || psz[-1] == ' ') && ( psz[cchKey] == ' ' || !psz[cchKey]) ) break; psz = strstr(psz + cchKey, pszKey); } if (psz) { /* remove it */ char *pszNext = RTStrStripL(psz + cchKey); if (*pszNext) memmove(psz, pszNext, strlen(pszNext) + 1); else *psz = '\0'; psz = RTStrStrip(pszKeys); /* update */ hrc = pMachine->SetExtraData(Bstr(pszKeyBase), Bstr(psz)); } RTStrFree(pszKeys); return hrc; } else RTMsgError(Internal::tr("Failed to delete key '%s' from '%s', string conversion error %Rrc!"), pszKey, pszKeyBase, vrc); return E_FAIL; } #endif /** * Sets a key value, does necessary error bitching. * * @returns COM status code. * @param pMachine The Machine object. * @param pszKeyBase The key base. * @param pszKey The key. * @param pszAttribute The attribute name. * @param pszValue The string value. */ static HRESULT SetString(ComPtr pMachine, const char *pszKeyBase, const char *pszKey, const char *pszAttribute, const char *pszValue) { HRESULT hrc = pMachine->SetExtraData(BstrFmt("%s/%s/%s", pszKeyBase, pszKey, pszAttribute).raw(), Bstr(pszValue).raw()); if (FAILED(hrc)) RTMsgError(Internal::tr("Failed to set '%s/%s/%s' to '%s'! hrc=%#x"), pszKeyBase, pszKey, pszAttribute, pszValue, hrc); return hrc; } /** * Sets a key value, does necessary error bitching. * * @returns COM status code. * @param pMachine The Machine object. * @param pszKeyBase The key base. * @param pszKey The key. * @param pszAttribute The attribute name. * @param u64Value The value. */ static HRESULT SetUInt64(ComPtr pMachine, const char *pszKeyBase, const char *pszKey, const char *pszAttribute, uint64_t u64Value) { char szValue[64]; RTStrPrintf(szValue, sizeof(szValue), "%#RX64", u64Value); return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue); } /** * Sets a key value, does necessary error bitching. * * @returns COM status code. * @param pMachine The Machine object. * @param pszKeyBase The key base. * @param pszKey The key. * @param pszAttribute The attribute name. * @param i64Value The value. */ static HRESULT SetInt64(ComPtr pMachine, const char *pszKeyBase, const char *pszKey, const char *pszAttribute, int64_t i64Value) { char szValue[64]; RTStrPrintf(szValue, sizeof(szValue), "%RI64", i64Value); return SetString(pMachine, pszKeyBase, pszKey, pszAttribute, szValue); } /** * Identical to the 'loadsyms' command. */ static RTEXITCODE CmdLoadSyms(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aSession); HRESULT hrc; /* * Get the VM */ ComPtr machine; CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(), machine.asOutParam()), RTEXITCODE_FAILURE); /* * Parse the command. */ const char *pszFilename; int64_t offDelta = 0; const char *pszModule = NULL; uint64_t ModuleAddress = UINT64_MAX; uint64_t ModuleSize = 0; /* filename */ if (argc < 2) return errorArgument(Internal::tr("Missing the filename argument!\n")); pszFilename = argv[1]; /* offDelta */ if (argc >= 3) { int vrc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read delta '%s', vrc=%Rrc\n"), argv[2], vrc); } /* pszModule */ if (argc >= 4) pszModule = argv[3]; /* ModuleAddress */ if (argc >= 5) { int vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', vrc=%Rrc\n"), argv[4], vrc); } /* ModuleSize */ if (argc >= 6) { int vrc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read module size '%s', vrc=%Rrc\n"), argv[5], vrc); } /* * Add extra data. */ Utf8Str KeyStr; hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr); if (SUCCEEDED(hrc)) hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Filename", pszFilename); if (SUCCEEDED(hrc) && argc >= 3) hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Delta", offDelta); if (SUCCEEDED(hrc) && argc >= 4) hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Module", pszModule); if (SUCCEEDED(hrc) && argc >= 5) hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleAddress", ModuleAddress); if (SUCCEEDED(hrc) && argc >= 6) hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleSize", ModuleSize); return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } /** * Identical to the 'loadmap' command. */ static RTEXITCODE CmdLoadMap(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aSession); HRESULT hrc; /* * Get the VM */ ComPtr machine; CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(), machine.asOutParam()), RTEXITCODE_FAILURE); /* * Parse the command. */ const char *pszFilename; uint64_t ModuleAddress = UINT64_MAX; const char *pszModule = NULL; uint64_t offSubtrahend = 0; uint32_t iSeg = UINT32_MAX; /* filename */ if (argc < 2) return errorArgument(Internal::tr("Missing the filename argument!\n")); pszFilename = argv[1]; /* address */ if (argc < 3) return errorArgument(Internal::tr("Missing the module address argument!\n")); int vrc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read module address '%s', vrc=%Rrc\n"), argv[2], vrc); /* name (optional) */ if (argc > 3) pszModule = argv[3]; /* subtrahend (optional) */ if (argc > 4) { vrc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read subtrahend '%s', vrc=%Rrc\n"), argv[4], vrc); } /* segment (optional) */ if (argc > 5) { vrc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg); if (RT_FAILURE(vrc)) return errorArgument(argv[0], Internal::tr("Failed to read segment number '%s', vrc=%Rrc\n"), argv[5], vrc); } /* * Add extra data. */ Utf8Str KeyStr; hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadmap", KeyStr); if (SUCCEEDED(hrc)) hrc = SetString(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Filename", pszFilename); if (SUCCEEDED(hrc)) hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Address", ModuleAddress); if (SUCCEEDED(hrc) && pszModule != NULL) hrc = SetString(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Name", pszModule); if (SUCCEEDED(hrc) && offSubtrahend != 0) hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Subtrahend", offSubtrahend); if (SUCCEEDED(hrc) && iSeg != UINT32_MAX) hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadmap", KeyStr.c_str(), "Segment", iSeg); return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } static DECLCALLBACK(void) handleVDError(void *pvUser, int vrc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) { RT_NOREF(pvUser); RTMsgErrorV(pszFormat, va); RTMsgError(Internal::tr("Error code %Rrc at %s(%u) in function %s"), vrc, RT_SRC_POS_ARGS); } static DECLCALLBACK(int) handleVDMessage(void *pvUser, const char *pszFormat, va_list va) { NOREF(pvUser); return RTPrintfV(pszFormat, va); } static RTEXITCODE CmdSetHDUUID(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Guid uuid; RTUUID rtuuid; enum eUuidType { HDUUID, HDPARENTUUID } uuidType; if (!strcmp(argv[0], "sethduuid")) { uuidType = HDUUID; if (argc != 3 && argc != 2) return errorSyntaxInternal(USAGE_I_SETHDUUID, Internal::tr("Not enough parameters")); /* if specified, take UUID, otherwise generate a new one */ if (argc == 3) { if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2]))) return errorSyntaxInternal(USAGE_I_SETHDUUID, Internal::tr("Invalid UUID parameter")); uuid = argv[2]; } else uuid.create(); } else if (!strcmp(argv[0], "sethdparentuuid")) { uuidType = HDPARENTUUID; if (argc != 3) return errorSyntaxInternal(USAGE_I_SETHDPARENTUUID, Internal::tr("Not enough parameters")); if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2]))) return errorSyntaxInternal(USAGE_I_SETHDPARENTUUID, Internal::tr("Invalid UUID parameter")); uuid = argv[2]; } else return errorSyntaxInternal(USAGE_I_SETHDUUID, Internal::tr("Invalid invocation")); /* just try it */ char *pszFormat = NULL; VDTYPE enmType = VDTYPE_INVALID; int vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, argv[1], VDTYPE_INVALID, &pszFormat, &enmType); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), vrc); PVDISK pDisk = NULL; PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); vrc = VDCreate(pVDIfs, enmType, &pDisk); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc); /* Open the image */ vrc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_INFO, NULL); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), vrc); if (uuidType == HDUUID) vrc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw()); else vrc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw()); if (RT_FAILURE(vrc)) RTMsgError(Internal::tr("Cannot set a new UUID: %Rrc"), vrc); else RTPrintf(Internal::tr("UUID changed to: %s\n"), uuid.toString().c_str()); VDCloseAll(pDisk); return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } static RTEXITCODE CmdDumpHDInfo(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); /* we need exactly one parameter: the image file */ if (argc != 1) { return errorSyntaxInternal(USAGE_I_DUMPHDINFO, Internal::tr("Not enough parameters")); } /* just try it */ char *pszFormat = NULL; VDTYPE enmType = VDTYPE_INVALID; int vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, argv[0], VDTYPE_INVALID, &pszFormat, &enmType); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Format autodetect failed: %Rrc"), vrc); PVDISK pDisk = NULL; PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); vrc = VDCreate(pVDIfs, enmType, &pDisk); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc); /* Open the image */ vrc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO, NULL); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the image: %Rrc"), vrc); VDDumpImages(pDisk); VDCloseAll(pDisk); return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } static int partRead(RTFILE File, PHOSTPARTITIONS pPart) { uint8_t aBuffer[512]; uint8_t partitionTableHeader[512]; uint32_t sector_size = 512; uint64_t lastUsableLBA = 0; VDISKPARTTYPE partitioningType; pPart->cPartitions = 0; memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions)); int vrc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL); if (RT_FAILURE(vrc)) return vrc; if (aBuffer[450] == 0xEE)/* check the sign of the GPT disk*/ { partitioningType = VDISKPARTTYPE_GPT; pPart->uPartitioningType = VDISKPARTTYPE_GPT;//partitioningType; if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa) return VERR_INVALID_PARAMETER; vrc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL); if (RT_SUCCESS(vrc)) { /** @todo r=bird: This is a 64-bit magic value, right... */ const char *l_ppth = (char *)partitionTableHeader; if (strncmp(l_ppth, "EFI PART", 8)) return VERR_INVALID_PARAMETER; /** @todo check GPT Version */ /** @todo r=bird: C have this handy concept called structures which * greatly simplify data access... (Someone is really lazy here!) */ #if 0 /* unused */ uint64_t firstUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[40], partitionTableHeader[41], partitionTableHeader[42], partitionTableHeader[43], partitionTableHeader[44], partitionTableHeader[45], partitionTableHeader[46], partitionTableHeader[47] ); #endif lastUsableLBA = RT_MAKE_U64_FROM_U8(partitionTableHeader[48], partitionTableHeader[49], partitionTableHeader[50], partitionTableHeader[51], partitionTableHeader[52], partitionTableHeader[53], partitionTableHeader[54], partitionTableHeader[55] ); uint32_t partitionsNumber = RT_MAKE_U32_FROM_U8(partitionTableHeader[80], partitionTableHeader[81], partitionTableHeader[82], partitionTableHeader[83] ); uint32_t partitionEntrySize = RT_MAKE_U32_FROM_U8(partitionTableHeader[84], partitionTableHeader[85], partitionTableHeader[86], partitionTableHeader[87] ); uint32_t currentEntry = 0; if (partitionEntrySize * partitionsNumber > 4 * _1M) { RTMsgError(Internal::tr("The GPT header seems corrupt because it contains too many entries")); return VERR_INVALID_PARAMETER; } uint8_t *pbPartTable = (uint8_t *)RTMemAllocZ(RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512)); if (!pbPartTable) { RTMsgError(Internal::tr("Allocating memory for the GPT partitions entries failed")); return VERR_NO_MEMORY; } /* partition entries begin from LBA2 */ /** @todo r=aeichner: Reading from LBA 2 is not always correct, the header will contain the starting LBA. */ vrc = RTFileReadAt(File, 1024, pbPartTable, RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512), NULL); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("Reading the partition table failed")); RTMemFree(pbPartTable); return vrc; } while (currentEntry < partitionsNumber) { uint8_t *partitionEntry = pbPartTable + currentEntry * partitionEntrySize; uint64_t start = RT_MAKE_U64_FROM_U8(partitionEntry[32], partitionEntry[33], partitionEntry[34], partitionEntry[35], partitionEntry[36], partitionEntry[37], partitionEntry[38], partitionEntry[39]); uint64_t end = RT_MAKE_U64_FROM_U8(partitionEntry[40], partitionEntry[41], partitionEntry[42], partitionEntry[43], partitionEntry[44], partitionEntry[45], partitionEntry[46], partitionEntry[47]); PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++]; pCP->uIndex = currentEntry + 1; pCP->uIndexWin = currentEntry + 1; pCP->uType = 0; pCP->uStartCylinder = 0; pCP->uStartHead = 0; pCP->uStartSector = 0; pCP->uEndCylinder = 0; pCP->uEndHead = 0; pCP->uEndSector = 0; pCP->uPartDataStart = 0; /* will be filled out later properly. */ pCP->cPartDataSectors = 0; if (start==0 || end==0) { pCP->uIndex = 0; pCP->uIndexWin = 0; --pPart->cPartitions; break; } else { pCP->uStart = start; pCP->uSize = (end +1) - start;/*+1 LBA because the last address is included*/ } ++currentEntry; } RTMemFree(pbPartTable); } } else { partitioningType = VDISKPARTTYPE_MBR; pPart->uPartitioningType = VDISKPARTTYPE_MBR;//partitioningType; if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa) return VERR_INVALID_PARAMETER; unsigned uExtended = (unsigned)-1; unsigned uIndexWin = 1; for (unsigned i = 0; i < 4; i++) { uint8_t *p = &aBuffer[0x1be + i * 16]; if (p[4] == 0) continue; PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++]; pCP->uIndex = i + 1; pCP->uType = p[4]; pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2); pCP->uStartHead = p[1]; pCP->uStartSector = p[2] & 0x3f; pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2); pCP->uEndHead = p[5]; pCP->uEndSector = p[6] & 0x3f; pCP->uStart = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]); pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]); pCP->uPartDataStart = 0; /* will be filled out later properly. */ pCP->cPartDataSectors = 0; if (PARTTYPE_IS_EXTENDED(p[4])) { if (uExtended == (unsigned)-1) { uExtended = (unsigned)(pCP - pPart->aPartitions); pCP->uIndexWin = 0; } else { RTMsgError(Internal::tr("More than one extended partition")); return VERR_INVALID_PARAMETER; } } else { pCP->uIndexWin = uIndexWin; uIndexWin++; } } if (uExtended != (unsigned)-1) { unsigned uIndex = 5; uint64_t uStart = pPart->aPartitions[uExtended].uStart; uint64_t uOffset = 0; if (!uStart) { RTMsgError(Internal::tr("Inconsistency for logical partition start")); return VERR_INVALID_PARAMETER; } do { vrc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL); if (RT_FAILURE(vrc)) return vrc; if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa) { RTMsgError(Internal::tr("Logical partition without magic")); return VERR_INVALID_PARAMETER; } uint8_t *p = &aBuffer[0x1be]; if (p[4] == 0) { RTMsgError(Internal::tr("Logical partition with type 0 encountered")); return VERR_INVALID_PARAMETER; } PHOSTPARTITION pCP = &pPart->aPartitions[pPart->cPartitions++]; pCP->uIndex = uIndex; pCP->uIndexWin = uIndexWin; pCP->uType = p[4]; pCP->uStartCylinder = (uint32_t)p[3] + ((uint32_t)(p[2] & 0xc0) << 2); pCP->uStartHead = p[1]; pCP->uStartSector = p[2] & 0x3f; pCP->uEndCylinder = (uint32_t)p[7] + ((uint32_t)(p[6] & 0xc0) << 2); pCP->uEndHead = p[5]; pCP->uEndSector = p[6] & 0x3f; uint32_t uStartOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]); if (!uStartOffset) { RTMsgError(Internal::tr("Invalid partition start offset")); return VERR_INVALID_PARAMETER; } pCP->uStart = uStart + uOffset + uStartOffset; pCP->uSize = RT_MAKE_U32_FROM_U8(p[12], p[13], p[14], p[15]); /* Fill out partitioning location info for EBR. */ pCP->uPartDataStart = uStart + uOffset; pCP->cPartDataSectors = uStartOffset; p += 16; if (p[4] == 0) uExtended = (unsigned)-1; else if (PARTTYPE_IS_EXTENDED(p[4])) { uExtended = uIndex; uIndex++; uIndexWin++; uOffset = RT_MAKE_U32_FROM_U8(p[8], p[9], p[10], p[11]); } else { RTMsgError(Internal::tr("Logical partition chain broken")); return VERR_INVALID_PARAMETER; } } while (uExtended != (unsigned)-1); } } /* Sort partitions in ascending order of start sector, plus a trivial * bit of consistency checking. */ for (unsigned i = 0; i < pPart->cPartitions-1; i++) { unsigned uMinIdx = i; uint64_t uMinVal = pPart->aPartitions[i].uStart; for (unsigned j = i + 1; j < pPart->cPartitions; j++) { if (pPart->aPartitions[j].uStart < uMinVal) { uMinIdx = j; uMinVal = pPart->aPartitions[j].uStart; } else if (pPart->aPartitions[j].uStart == uMinVal) { RTMsgError(Internal::tr("Two partitions start at the same place")); return VERR_INVALID_PARAMETER; } else if (pPart->aPartitions[j].uStart == 0) { RTMsgError(Internal::tr("Partition starts at sector 0")); return VERR_INVALID_PARAMETER; } } if (uMinIdx != i) { /* Swap entries at index i and uMinIdx. */ memcpy(&pPart->aPartitions[pPart->cPartitions], &pPart->aPartitions[i], sizeof(HOSTPARTITION)); memcpy(&pPart->aPartitions[i], &pPart->aPartitions[uMinIdx], sizeof(HOSTPARTITION)); memcpy(&pPart->aPartitions[uMinIdx], &pPart->aPartitions[pPart->cPartitions], sizeof(HOSTPARTITION)); } } /* Fill out partitioning location info for MBR or GPT. */ pPart->aPartitions[0].uPartDataStart = 0; pPart->aPartitions[0].cPartDataSectors = pPart->aPartitions[0].uStart; /* Fill out partitioning location info for backup GPT. */ if (partitioningType == VDISKPARTTYPE_GPT) { pPart->aPartitions[pPart->cPartitions-1].uPartDataStart = lastUsableLBA+1; pPart->aPartitions[pPart->cPartitions-1].cPartDataSectors = 33; /* Now do a some partition table consistency checking, to reject the most * obvious garbage which can lead to trouble later. */ uint64_t uPrevEnd = 0; for (unsigned i = 0; i < pPart->cPartitions; i++) { if (pPart->aPartitions[i].cPartDataSectors) uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors; if (pPart->aPartitions[i].uStart < uPrevEnd && pPart->cPartitions-1 != i) { RTMsgError(Internal::tr("Overlapping GPT partitions")); return VERR_INVALID_PARAMETER; } } } else { /* Now do a some partition table consistency checking, to reject the most * obvious garbage which can lead to trouble later. */ uint64_t uPrevEnd = 0; for (unsigned i = 0; i < pPart->cPartitions; i++) { if (pPart->aPartitions[i].cPartDataSectors) uPrevEnd = pPart->aPartitions[i].uPartDataStart + pPart->aPartitions[i].cPartDataSectors; if (pPart->aPartitions[i].uStart < uPrevEnd) { RTMsgError(Internal::tr("Overlapping MBR partitions")); return VERR_INVALID_PARAMETER; } if (!PARTTYPE_IS_EXTENDED(pPart->aPartitions[i].uType)) uPrevEnd = pPart->aPartitions[i].uStart + pPart->aPartitions[i].uSize; } } return VINF_SUCCESS; } static RTEXITCODE CmdListPartitions(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Utf8Str rawdisk; /* let's have a closer look at the arguments */ for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "-rawdisk") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; rawdisk = argv[i]; } else { return errorSyntaxInternal(USAGE_I_LISTPARTITIONS, Internal::tr("Invalid parameter '%s'"), argv[i]); } } if (rawdisk.isEmpty()) return errorSyntaxInternal(USAGE_I_LISTPARTITIONS, Internal::tr("Mandatory parameter -rawdisk missing")); RTFILE hRawFile; int vrc = RTFileOpen(&hRawFile, rawdisk.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the raw disk: %Rrc"), vrc); HOSTPARTITIONS partitions; vrc = partRead(hRawFile, &partitions); /* Don't bail out on errors, print the table and return the result code. */ RTPrintf(Internal::tr("Number Type StartCHS EndCHS Size (MiB) Start (Sect)\n")); for (unsigned i = 0; i < partitions.cPartitions; i++) { /* Don't show the extended partition, otherwise users might think they * can add it to the list of partitions for raw partition access. */ if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType)) continue; RTPrintf("%-7u %#04x %-4u/%-3u/%-2u %-4u/%-3u/%-2u %10llu %10llu\n", partitions.aPartitions[i].uIndex, partitions.aPartitions[i].uType, partitions.aPartitions[i].uStartCylinder, partitions.aPartitions[i].uStartHead, partitions.aPartitions[i].uStartSector, partitions.aPartitions[i].uEndCylinder, partitions.aPartitions[i].uEndHead, partitions.aPartitions[i].uEndSector, partitions.aPartitions[i].uSize / 2048, partitions.aPartitions[i].uStart); } return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } static const RTGETOPTDEF g_aCreateRawVMDKOptions[] = { { "--filename", 'f', RTGETOPT_REQ_STRING }, { "-filename", 'f', RTGETOPT_REQ_STRING }, { "--rawdisk", 'd', RTGETOPT_REQ_STRING }, { "-rawdisk", 'd', RTGETOPT_REQ_STRING }, { "--partitions", 'p', RTGETOPT_REQ_STRING }, { "-partitions", 'p', RTGETOPT_REQ_STRING }, { "--mbr", 'm', RTGETOPT_REQ_STRING }, { "-mbr", 'm', RTGETOPT_REQ_STRING }, #if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD) || defined(RT_OS_WINDOWS) { "--relative", 'r', RTGETOPT_REQ_NOTHING }, { "-relative", 'r', RTGETOPT_REQ_NOTHING }, #endif /* RT_OS_LINUX || RT_OS_FREEBSD || RT_OS_WINDOWS */ }; static RTEXITCODE CmdCreateRawVMDK(int argc, char **argv, HandlerArg *a) { const char *pszFilename = NULL; const char *pszRawdisk = NULL; const char *pszPartitions = NULL; const char *pszMbr = NULL; bool fRelative = false; int c; RTGETOPTUNION ValueUnion; RTGETOPTSTATE GetState; RTGetOptInit(&GetState, argc, argv, g_aCreateRawVMDKOptions, RT_ELEMENTS(g_aCreateRawVMDKOptions), 0, 0); while ((c = RTGetOpt(&GetState, &ValueUnion))) { switch (c) { case 'f': // --filename pszFilename = ValueUnion.psz; break; case 'd': // --rawdisk pszRawdisk = ValueUnion.psz; break; case 'p': // --partitions pszPartitions = ValueUnion.psz; break; case 'm': // --mbr pszMbr = ValueUnion.psz; break; #if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD) || defined(RT_OS_WINDOWS) case 'r': // --relative fRelative = true; break; #endif /* RT_OS_LINUX || RT_OS_FREEBSD || RT_OS_WINDOWS */ default: return errorGetOptInternal(USAGE_I_CREATERAWVMDK, c, &ValueUnion); } } if (!pszFilename || !*pszFilename) return errorSyntaxInternal(USAGE_I_CREATERAWVMDK, Internal::tr("Mandatory parameter --filename missing")); if (!pszRawdisk || !*pszRawdisk) return errorSyntaxInternal(USAGE_I_CREATERAWVMDK, Internal::tr("Mandatory parameter --rawdisk missing")); if (!pszPartitions && pszMbr) return errorSyntaxInternal(USAGE_I_CREATERAWVMDK, Internal::tr("The parameter --mbr is only valid when the parameter -partitions is also present")); /* Construct the equivalent 'VBoxManage createmedium disk --variant RawDisk ...' command line. */ size_t cMaxArgs = 9; /* all possible 'createmedium' args based on the 'createrawvmdk' options + 1 for NULL */ char **papszNewArgv = (char **)RTMemAllocZ(sizeof(papszNewArgv[0]) * cMaxArgs); if (!papszNewArgv) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Failed to allocate memory for argument array")); int cArgs = 0; papszNewArgv[cArgs++] = RTStrDup("disk"); papszNewArgv[cArgs++] = RTStrDup("--variant=RawDisk"); papszNewArgv[cArgs++] = RTStrDup("--format=VMDK"); for (int i = 0; i < cArgs; i++) if (!papszNewArgv[i]) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Failed to allocate memory for argument array")); if ( RTStrAPrintf(&papszNewArgv[cArgs++], "--filename=%s", pszFilename) == -1 || RTStrAPrintf(&papszNewArgv[cArgs++], "--property=RawDrive=%s", pszRawdisk) == -1 || (pszPartitions && (RTStrAPrintf(&papszNewArgv[cArgs++], "--property=Partitions=%s", pszPartitions) == -1)) || (pszMbr && (RTStrAPrintf(&papszNewArgv[cArgs++], "--property-filename=%s", pszMbr) == -1)) || (fRelative && (RTStrAPrintf(&papszNewArgv[cArgs++], "--property=Relative=%d", fRelative) == -1))) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Failed to allocate memory for argument array")); papszNewArgv[cArgs] = NULL; RTStrmPrintf(g_pStdErr, Internal::tr("\nThe 'createrawvdk' subcommand is deprecated. The equivalent functionality is\n" "available using the 'VBoxManage createmedium' command and should be used\n" "instead. See 'VBoxManage help createmedium' for details.\n\n")); a->argc = cArgs; a->argv = papszNewArgv; RTEXITCODE rcExit = handleCreateMedium(a); for (int i = 0; i < cArgs; i++) RTStrFree(papszNewArgv[i]); RTMemFree(papszNewArgv); return rcExit; } static RTEXITCODE CmdRenameVMDK(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Utf8Str src; Utf8Str dst; /* Parse the arguments. */ for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "-from") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; src = argv[i]; } else if (strcmp(argv[i], "-to") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; dst = argv[i]; } else { return errorSyntaxInternal(USAGE_I_RENAMEVMDK, Internal::tr("Invalid parameter '%s'"), argv[i]); } } if (src.isEmpty()) return errorSyntaxInternal(USAGE_I_RENAMEVMDK, Internal::tr("Mandatory parameter -from missing")); if (dst.isEmpty()) return errorSyntaxInternal(USAGE_I_RENAMEVMDK, Internal::tr("Mandatory parameter -to missing")); PVDISK pDisk = NULL; PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; int vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc); vrc = VDOpen(pDisk, "VMDK", src.c_str(), VD_OPEN_FLAGS_NORMAL, NULL); if (RT_SUCCESS(vrc)) { vrc = VDCopy(pDisk, 0, pDisk, "VMDK", dst.c_str(), true, 0, VD_IMAGE_FLAGS_NONE, NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL, NULL); if (RT_FAILURE(vrc)) RTMsgError(Internal::tr("Cannot rename the image: %Rrc"), vrc); } else RTMsgError(Internal::tr("Cannot create the source image: %Rrc"), vrc); VDCloseAll(pDisk); return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } static RTEXITCODE CmdConvertToRaw(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Utf8Str srcformat; Utf8Str src; Utf8Str dst; bool fWriteToStdOut = false; /* Parse the arguments. */ for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "-format") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; srcformat = argv[i]; } else if (src.isEmpty()) { src = argv[i]; } else if (dst.isEmpty()) { dst = argv[i]; #ifdef ENABLE_CONVERT_RAW_TO_STDOUT if (!strcmp(argv[i], "stdout")) fWriteToStdOut = true; #endif /* ENABLE_CONVERT_RAW_TO_STDOUT */ } else { return errorSyntaxInternal(USAGE_I_CONVERTTORAW, Internal::tr("Invalid parameter '%s'"), argv[i]); } } if (src.isEmpty()) return errorSyntaxInternal(USAGE_I_CONVERTTORAW, Internal::tr("Mandatory filename parameter missing")); if (dst.isEmpty()) return errorSyntaxInternal(USAGE_I_CONVERTTORAW, Internal::tr("Mandatory outputfile parameter missing")); PVDISK pDisk = NULL; PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; int vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); /** @todo Support convert to raw for floppy and DVD images too. */ vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); if (RT_FAILURE(vrc)) return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create the virtual disk container: %Rrc"), vrc); /* Open raw output file. */ RTFILE outFile; vrc = VINF_SUCCESS; if (fWriteToStdOut) vrc = RTFileFromNative(&outFile, 1); else vrc = RTFileOpen(&outFile, dst.c_str(), RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_DENY_ALL); if (RT_FAILURE(vrc)) { VDCloseAll(pDisk); return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot create destination file \"%s\": %Rrc"), dst.c_str(), vrc); } if (srcformat.isEmpty()) { char *pszFormat = NULL; VDTYPE enmType = VDTYPE_INVALID; vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, src.c_str(), VDTYPE_INVALID, &pszFormat, &enmType); if (RT_FAILURE(vrc) || enmType != VDTYPE_HDD) { VDCloseAll(pDisk); if (!fWriteToStdOut) { RTFileClose(outFile); RTFileDelete(dst.c_str()); } if (RT_FAILURE(vrc)) RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"), vrc); else RTMsgError(Internal::tr("Only converting harddisk images is supported")); return RTEXITCODE_FAILURE; } srcformat = pszFormat; RTStrFree(pszFormat); } vrc = VDOpen(pDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL); if (RT_FAILURE(vrc)) { VDCloseAll(pDisk); if (!fWriteToStdOut) { RTFileClose(outFile); RTFileDelete(dst.c_str()); } return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot open the source image: %Rrc"), vrc); } uint64_t cbSize = VDGetSize(pDisk, VD_LAST_IMAGE); uint64_t offFile = 0; #define RAW_BUFFER_SIZE _128K size_t cbBuf = RAW_BUFFER_SIZE; void *pvBuf = RTMemAlloc(cbBuf); if (pvBuf) { RTStrmPrintf(g_pStdErr, Internal::tr("Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", "", cbSize), src.c_str(), cbSize, (cbSize + _1M - 1) / _1M); while (offFile < cbSize) { size_t cb = (size_t)RT_MIN(cbSize - offFile, cbBuf); vrc = VDRead(pDisk, offFile, pvBuf, cb); if (RT_FAILURE(vrc)) break; vrc = RTFileWrite(outFile, pvBuf, cb, NULL); if (RT_FAILURE(vrc)) break; offFile += cb; } RTMemFree(pvBuf); if (RT_FAILURE(vrc)) { VDCloseAll(pDisk); if (!fWriteToStdOut) { RTFileClose(outFile); RTFileDelete(dst.c_str()); } return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Cannot copy image data: %Rrc"), vrc); } } else { vrc = VERR_NO_MEMORY; VDCloseAll(pDisk); if (!fWriteToStdOut) { RTFileClose(outFile); RTFileDelete(dst.c_str()); } return RTMsgErrorExit(RTEXITCODE_FAILURE, Internal::tr("Out of memory allocating read buffer")); } if (!fWriteToStdOut) RTFileClose(outFile); VDCloseAll(pDisk); return RTEXITCODE_SUCCESS; } static RTEXITCODE CmdConvertHardDisk(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Utf8Str srcformat; Utf8Str dstformat; Utf8Str src; Utf8Str dst; int vrc; PVDISK pSrcDisk = NULL; PVDISK pDstDisk = NULL; VDTYPE enmSrcType = VDTYPE_INVALID; /* Parse the arguments. */ for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "-srcformat") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; srcformat = argv[i]; } else if (strcmp(argv[i], "-dstformat") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; dstformat = argv[i]; } else if (src.isEmpty()) { src = argv[i]; } else if (dst.isEmpty()) { dst = argv[i]; } else { return errorSyntaxInternal(USAGE_I_CONVERTHD, Internal::tr("Invalid parameter '%s'"), argv[i]); } } if (src.isEmpty()) return errorSyntaxInternal(USAGE_I_CONVERTHD, Internal::tr("Mandatory input image parameter missing")); if (dst.isEmpty()) return errorSyntaxInternal(USAGE_I_CONVERTHD, Internal::tr("Mandatory output image parameter missing")); PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); do { /* Try to determine input image format */ if (srcformat.isEmpty()) { char *pszFormat = NULL; vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, src.c_str(), VDTYPE_HDD, &pszFormat, &enmSrcType); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"), vrc); break; } srcformat = pszFormat; RTStrFree(pszFormat); } vrc = VDCreate(pVDIfs, enmSrcType, &pSrcDisk); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("Cannot create the source virtual disk container: %Rrc"), vrc); break; } /* Open the input image */ vrc = VDOpen(pSrcDisk, srcformat.c_str(), src.c_str(), VD_OPEN_FLAGS_READONLY, NULL); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("Cannot open the source image: %Rrc"), vrc); break; } /* Output format defaults to VDI */ if (dstformat.isEmpty()) dstformat = "VDI"; vrc = VDCreate(pVDIfs, enmSrcType, &pDstDisk); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("Cannot create the destination virtual disk container: %Rrc"), vrc); break; } uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE); RTStrmPrintf(g_pStdErr, Internal::tr("Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", "", cbSize), src.c_str(), cbSize, (cbSize + _1M - 1) / _1M); /* Create the output image */ vrc = VDCopy(pSrcDisk, VD_LAST_IMAGE, pDstDisk, dstformat.c_str(), dst.c_str(), false, 0, VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED, NULL, VD_OPEN_FLAGS_NORMAL, NULL, NULL, NULL); if (RT_FAILURE(vrc)) { RTMsgError(Internal::tr("Cannot copy the image: %Rrc"), vrc); break; } } while (0); if (pDstDisk) VDCloseAll(pDstDisk); if (pSrcDisk) VDCloseAll(pSrcDisk); return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } /** * Tries to repair a corrupted hard disk image. * * @returns VBox status code */ static RTEXITCODE CmdRepairHardDisk(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); Utf8Str image; Utf8Str format; int vrc; bool fDryRun = false; /* Parse the arguments. */ for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "-dry-run") == 0) { fDryRun = true; } else if (strcmp(argv[i], "-format") == 0) { if (argc <= i + 1) { return errorArgument(Internal::tr("Missing argument to '%s'"), argv[i]); } i++; format = argv[i]; } else if (image.isEmpty()) { image = argv[i]; } else { return errorSyntaxInternal(USAGE_I_REPAIRHD, Internal::tr("Invalid parameter '%s'"), argv[i]); } } if (image.isEmpty()) return errorSyntaxInternal(USAGE_I_REPAIRHD, Internal::tr("Mandatory input image parameter missing")); PVDINTERFACE pVDIfs = NULL; VDINTERFACEERROR vdInterfaceError; vdInterfaceError.pfnError = handleVDError; vdInterfaceError.pfnMessage = handleVDMessage; vrc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, NULL, sizeof(VDINTERFACEERROR), &pVDIfs); AssertRC(vrc); do { /* Try to determine input image format */ if (format.isEmpty()) { char *pszFormat = NULL; VDTYPE enmSrcType = VDTYPE_INVALID; vrc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, image.c_str(), VDTYPE_HDD, &pszFormat, &enmSrcType); if (RT_FAILURE(vrc) && (vrc != VERR_VD_IMAGE_CORRUPTED)) { RTMsgError(Internal::tr("No file format specified and autodetect failed - please specify format: %Rrc"), vrc); break; } format = pszFormat; RTStrFree(pszFormat); } uint32_t fFlags = 0; if (fDryRun) fFlags |= VD_REPAIR_DRY_RUN; vrc = VDRepair(pVDIfs, NULL, image.c_str(), format.c_str(), fFlags); } while (0); return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; } /** * Unloads the necessary driver. * * @returns VBox status code */ static RTEXITCODE CmdModUninstall(void) { int vrc = SUPR3Uninstall(); if (RT_SUCCESS(vrc) || vrc == VERR_NOT_IMPLEMENTED) return RTEXITCODE_SUCCESS; return RTEXITCODE_FAILURE; } /** * Loads the necessary driver. * * @returns VBox status code */ static RTEXITCODE CmdModInstall(void) { int vrc = SUPR3Install(); if (RT_SUCCESS(vrc) || vrc == VERR_NOT_IMPLEMENTED) return RTEXITCODE_SUCCESS; return RTEXITCODE_FAILURE; } static RTEXITCODE CmdDebugLog(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { /* * The first parameter is the name or UUID of a VM with a direct session * that we wish to open. */ if (argc < 1) return errorSyntaxInternal(USAGE_I_DEBUGLOG, Internal::tr("Missing VM name/UUID")); ComPtr ptrMachine; HRESULT hrc; CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE); CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), RTEXITCODE_FAILURE); /* * Get the debugger interface. */ ComPtr ptrConsole; CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE); ComPtr ptrDebugger; CHECK_ERROR_RET(ptrConsole, COMGETTER(Debugger)(ptrDebugger.asOutParam()), RTEXITCODE_FAILURE); /* * Parse the command. */ bool fEnablePresent = false; bool fEnable = false; bool fFlagsPresent = false; RTCString strFlags; bool fGroupsPresent = false; RTCString strGroups; bool fDestsPresent = false; RTCString strDests; static const RTGETOPTDEF s_aOptions[] = { { "--disable", 'E', RTGETOPT_REQ_NOTHING }, { "--enable", 'e', RTGETOPT_REQ_NOTHING }, { "--flags", 'f', RTGETOPT_REQ_STRING }, { "--groups", 'g', RTGETOPT_REQ_STRING }, { "--destinations", 'd', RTGETOPT_REQ_STRING } }; int ch; RTGETOPTUNION ValueUnion; RTGETOPTSTATE GetState; RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0); while ((ch = RTGetOpt(&GetState, &ValueUnion))) { switch (ch) { case 'e': fEnablePresent = true; fEnable = true; break; case 'E': fEnablePresent = true; fEnable = false; break; case 'f': fFlagsPresent = true; if (*ValueUnion.psz) { if (strFlags.isNotEmpty()) strFlags.append(' '); strFlags.append(ValueUnion.psz); } break; case 'g': fGroupsPresent = true; if (*ValueUnion.psz) { if (strGroups.isNotEmpty()) strGroups.append(' '); strGroups.append(ValueUnion.psz); } break; case 'd': fDestsPresent = true; if (*ValueUnion.psz) { if (strDests.isNotEmpty()) strDests.append(' '); strDests.append(ValueUnion.psz); } break; default: return errorGetOptInternal(USAGE_I_DEBUGLOG, ch, &ValueUnion); } } /* * Do the job. */ if (fEnablePresent && !fEnable) CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(FALSE), RTEXITCODE_FAILURE); /** @todo flags, groups destination. */ if (fFlagsPresent || fGroupsPresent || fDestsPresent) RTMsgWarning(Internal::tr("One or more of the requested features are not implemented! Feel free to do this.")); if (fEnablePresent && fEnable) CHECK_ERROR_RET(ptrDebugger, COMSETTER(LogEnabled)(TRUE), RTEXITCODE_FAILURE); return RTEXITCODE_SUCCESS; } /** * Generate a SHA-256 password hash */ static RTEXITCODE CmdGeneratePasswordHash(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { RT_NOREF(aVirtualBox, aSession); /* one parameter, the password to hash */ if (argc != 1) return errorSyntaxInternal(USAGE_I_PASSWORDHASH, Internal::tr("password to hash required")); uint8_t abDigest[RTSHA256_HASH_SIZE]; RTSha256(argv[0], strlen(argv[0]), abDigest); char pszDigest[RTSHA256_DIGEST_LEN + 1]; RTSha256ToString(abDigest, pszDigest, sizeof(pszDigest)); RTPrintf(Internal::tr("Password hash: %s\n"), pszDigest); return RTEXITCODE_SUCCESS; } /** * Print internal guest statistics or * set internal guest statistics update interval if specified */ static RTEXITCODE CmdGuestStats(int argc, char **argv, ComPtr aVirtualBox, ComPtr aSession) { /* one parameter, guest name */ if (argc < 1) return errorSyntaxInternal(USAGE_I_GUESTSTATS, Internal::tr("Missing VM name/UUID")); /* * Parse the command. */ ULONG aUpdateInterval = 0; static const RTGETOPTDEF s_aOptions[] = { { "--interval", 'i', RTGETOPT_REQ_UINT32 } }; int ch; RTGETOPTUNION ValueUnion; RTGETOPTSTATE GetState; RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0); while ((ch = RTGetOpt(&GetState, &ValueUnion))) { switch (ch) { case 'i': aUpdateInterval = ValueUnion.u32; break; default: return errorGetOptInternal(USAGE_I_GUESTSTATS, ch, &ValueUnion); } } if (argc > 1 && aUpdateInterval == 0) return errorSyntaxInternal(USAGE_I_GUESTSTATS, Internal::tr("Invalid update interval specified")); RTPrintf(Internal::tr("argc=%d interval=%u\n"), argc, aUpdateInterval); ComPtr ptrMachine; HRESULT hrc; CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[0]).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE); CHECK_ERROR_RET(ptrMachine, LockMachine(aSession, LockType_Shared), RTEXITCODE_FAILURE); /* * Get the guest interface. */ ComPtr ptrConsole; CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE); ComPtr ptrGuest; CHECK_ERROR_RET(ptrConsole, COMGETTER(Guest)(ptrGuest.asOutParam()), RTEXITCODE_FAILURE); if (aUpdateInterval) CHECK_ERROR_RET(ptrGuest, COMSETTER(StatisticsUpdateInterval)(aUpdateInterval), RTEXITCODE_FAILURE); else { ULONG mCpuUser, mCpuKernel, mCpuIdle; ULONG mMemTotal, mMemFree, mMemBalloon, mMemShared, mMemCache, mPageTotal; ULONG ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal; CHECK_ERROR_RET(ptrGuest, InternalGetStatistics(&mCpuUser, &mCpuKernel, &mCpuIdle, &mMemTotal, &mMemFree, &mMemBalloon, &mMemShared, &mMemCache, &mPageTotal, &ulMemAllocTotal, &ulMemFreeTotal, &ulMemBalloonTotal, &ulMemSharedTotal), RTEXITCODE_FAILURE); RTPrintf("mCpuUser=%u mCpuKernel=%u mCpuIdle=%u\n" "mMemTotal=%u mMemFree=%u mMemBalloon=%u mMemShared=%u mMemCache=%u\n" "mPageTotal=%u ulMemAllocTotal=%u ulMemFreeTotal=%u ulMemBalloonTotal=%u ulMemSharedTotal=%u\n", mCpuUser, mCpuKernel, mCpuIdle, mMemTotal, mMemFree, mMemBalloon, mMemShared, mMemCache, mPageTotal, ulMemAllocTotal, ulMemFreeTotal, ulMemBalloonTotal, ulMemSharedTotal); } return RTEXITCODE_SUCCESS; } /** * Wrapper for handling internal commands */ RTEXITCODE handleInternalCommands(HandlerArg *a) { /* at least a command is required */ if (a->argc < 1) return errorSyntaxInternal(USAGE_I_ALL, Internal::tr("Command missing")); /* * The 'string switch' on command name. */ const char *pszCmd = a->argv[0]; if (!strcmp(pszCmd, "loadmap")) return CmdLoadMap(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "loadsyms")) return CmdLoadSyms(a->argc - 1, &a->argv[1], a->virtualBox, a->session); //if (!strcmp(pszCmd, "unloadsyms")) // return CmdUnloadSyms(argc - 1, &a->argv[1]); if (!strcmp(pszCmd, "sethduuid") || !strcmp(pszCmd, "sethdparentuuid")) return CmdSetHDUUID(a->argc, &a->argv[0], a->virtualBox, a->session); if (!strcmp(pszCmd, "dumphdinfo")) return CmdDumpHDInfo(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "listpartitions")) return CmdListPartitions(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "createrawvmdk")) return CmdCreateRawVMDK(a->argc - 1, &a->argv[1], a); if (!strcmp(pszCmd, "renamevmdk")) return CmdRenameVMDK(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "converttoraw")) return CmdConvertToRaw(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "converthd")) return CmdConvertHardDisk(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "modinstall")) return CmdModInstall(); if (!strcmp(pszCmd, "moduninstall")) return CmdModUninstall(); if (!strcmp(pszCmd, "debuglog")) return CmdDebugLog(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "passwordhash")) return CmdGeneratePasswordHash(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "gueststats")) return CmdGuestStats(a->argc - 1, &a->argv[1], a->virtualBox, a->session); if (!strcmp(pszCmd, "repairhd")) return CmdRepairHardDisk(a->argc - 1, &a->argv[1], a->virtualBox, a->session); /* default: */ return errorSyntaxInternal(USAGE_I_ALL, Internal::tr("Invalid command '%s'"), a->argv[0]); }