diff options
Diffstat (limited to 'src/VBox/Frontends/VBoxManage')
26 files changed, 31577 insertions, 0 deletions
diff --git a/src/VBox/Frontends/VBoxManage/Makefile.kmk b/src/VBox/Frontends/VBoxManage/Makefile.kmk new file mode 100644 index 00000000..02b93dc4 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/Makefile.kmk @@ -0,0 +1,208 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for VBoxManage (the cli frontend). +# + +# +# Copyright (C) 2006-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# + +SUB_DEPTH = ../../../.. +include $(KBUILD_PATH)/subheader.kmk + +include $(PATH_ROOT)/doc/manual/Config.kmk + + +VBOX_COMMON_VBOXMANAGE_DEFS = \ + $(if $(VBOX_WITH_AHCI), VBOX_WITH_AHCI) \ + $(if $(VBOX_WITH_COPYTOGUEST),VBOX_WITH_COPYTOGUEST) \ + $(if $(VBOX_WITH_E1000),VBOX_WITH_E1000) \ + $(if $(VBOX_WITH_GUEST_CONTROL),VBOX_WITH_GUEST_CONTROL) \ + $(if $(VBOX_WITH_GUEST_PROPS),VBOX_WITH_GUEST_PROPS) \ + $(if $(VBOX_WITH_HEADLESS), VBOX_WITH_HEADLESS) \ + $(if $(VBOX_WITH_HGCM), VBOX_WITH_HGCM) \ + $(if $(VBOX_WITH_HOSTNETIF_API), VBOX_WITH_HOSTNETIF_API) \ + $(if $(VBOX_WITH_NETFLT), VBOX_WITH_NETFLT) \ + $(if $(VBOX_WITH_AUDIO_OSS), VBOX_WITH_AUDIO_OSS) \ + $(if $(VBOX_WITH_AUDIO_ALSA), VBOX_WITH_AUDIO_ALSA) \ + $(if $(VBOX_WITH_AUDIO_PULSE),VBOX_WITH_AUDIO_PULSE) \ + $(if $(VBOX_WITH_SCSI), VBOX_WITH_SCSI) \ + $(if $(VBOX_WITH_VBOXSDL), VBOX_WITH_VBOXSDL) \ + $(if $(VBOX_WITH_VIDEOHWACCEL), VBOX_WITH_VIDEOHWACCEL) \ + $(if $(VBOX_WITH_VIRTIO),VBOX_WITH_VIRTIO) \ + $(if $(VBOX_WITH_USB_CARDREADER),VBOX_WITH_USB_CARDREADER) \ + $(if $(VBOX_WITH_PCI_PASSTHROUGH),VBOX_WITH_PCI_PASSTHROUGH) \ + $(if $(VBOX_WITH_RECORDING),VBOX_WITH_RECORDING) \ + $(if $(VBOX_WITH_AUDIO_RECORDING),VBOX_WITH_AUDIO_RECORDING) \ + $(if $(VBOX_WITH_NAT_SERVICE),VBOX_WITH_NAT_SERVICE) \ + $(if $(VBOX_WITH_VMSVGA),VBOX_WITH_VMSVGA) + + +ifdef VBOX_WITH_DOCS + PROGRAMS += VBoxManageHelp +endif +VBoxManageHelp_TEMPLATE = VBoxAdvBldProg +VBoxManageHelp_DEFS += \ + VBOX_ONLY_DOCS \ + $(VBOX_COMMON_VBOXMANAGE_DEFS) +VBoxManageHelp_SOURCES = \ + VBoxManage.cpp \ + VBoxManageHelp.cpp \ + $(if $(VBOX_WITH_GUEST_PROPS),VBoxManageGuestProp.cpp) \ + $(if $(VBOX_WITH_GUEST_CONTROL),VBoxManageGuestCtrl.cpp) + +ifndef VBOX_ONLY_DOCS + PROGRAMS += VBoxManage + VBoxManage_TEMPLATE = VBOXMAINCLIENTEXE + VBoxManage_DEFS += $(VBOX_COMMON_VBOXMANAGE_DEFS) + VBoxManage_DEFS.win = _WIN32_WINNT=0x0500 + VBoxManage_INCS = \ + $(VBoxManage_0_OUTDIR) + VBoxManage_INTERMEDIATES = \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.h + VBoxManage_SOURCES = \ + VBoxManage.cpp \ + VBoxInternalManage.cpp \ + VBoxManageAppliance.cpp \ + VBoxManageBandwidthControl.cpp \ + VBoxManageControlVM.cpp \ + VBoxManageDebugVM.cpp \ + VBoxManageDHCPServer.cpp \ + VBoxManageDisk.cpp \ + $(if $(VBOX_WITH_GUEST_CONTROL),VBoxManageGuestCtrl.cpp) \ + $(if $(VBOX_WITH_GUEST_CONTROL),VBoxManageGuestCtrlListener.cpp) \ + $(if $(VBOX_WITH_GUEST_PROPS),VBoxManageGuestProp.cpp) \ + VBoxManageHelp.cpp \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.cpp \ + VBoxManageHostonly.cpp \ + VBoxManageInfo.cpp \ + VBoxManageList.cpp \ + VBoxManageMetrics.cpp \ + VBoxManageMisc.cpp \ + VBoxManageModifyVM.cpp \ + VBoxManageSnapshot.cpp \ + VBoxManageStorageController.cpp \ + VBoxManageUSB.cpp \ + $(if $(VBOX_WITH_NAT_SERVICE),VBoxManageNATNetwork.cpp,) \ + $(if $(VBOX_WITH_NAT_SERVICE),../../NetworkServices/NetLib/VBoxNetPortForwardString.cpp,) + VBoxManage_SOURCES.win = \ + VBoxManage.rc + VBoxManage_LIBS += $(LIB_DDU) + + # VBoxNetPortForwardString.h + VBoxManageNATNetwork.cpp_INCS += ../../NetworkServices/NetLib/ + +endif # VBOX_ONLY_DOCS + +ifneq ($(KBUILD_TARGET),win) + # Workaround for buggy gcc-4.3 compilers, see + # + # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=36474 + # + # Some later revisions of version 4.3.1 are known to work so we assume + # that version 4.3.2 or later has this bug definitely fixed. + VBoxManage_CXXFLAGS.release += \ + $(if $(VBOX_GCC_VERSION_CXX),$(if-expr $(VBOX_GCC_VERSION_CXX) < 40300 || $(VBOX_GCC_VERSION_CXX) > 40301,,--param max-fields-for-field-sensitive=0),) + VBoxManageHelp_CXXFLAGS.release = $(VBoxManage_CXXFLAGS.release) +endif + + +# +# VBoxManage built-in help from XML refentry in doc/manual/en_US/. +# +$(call KB_FN_DO_PASS0_ON_TARGET,VBoxManage) + +VBoxManage_CLEAN += \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.cpp \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.cpp.ts \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.h \ + $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.h.ts \ + $(addprefix $(VBoxManage_0_OUTDIR)/,$(filter man_VBoxManage-%,$(VBOX_MANUAL_XML_REFENTRY_FILES))) + + + +# Preprocess the xml files, applying remarks. +$(foreach file,$(filter man_VBoxManage-%,$(VBOX_MANUAL_XML_REFENTRY_FILES)) \ +, $(evalcall2 def_vbox_refentry_preprocess_for_manpage,$(VBoxManage_0_OUTDIR),$(file),$(VBOX_PATH_MANUAL_SRC)/en_US/$(file))) + + +# Generate the .cpp file. +$(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.cpp.ts \ ++| $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.cpp: \ + $(VBOX_DOCBOOK_REFENTRY_TO_C_HELP) \ + $(addprefix $(VBoxManage_0_OUTDIR)/,$(filter man_VBoxManage-%,$(VBOX_MANUAL_XML_REFENTRY_FILES))) \ + $(VBOX_XML_CATALOG) $(VBOX_XML_CATALOG_DOCBOOK) $(MAKEFILE) | $$(dir $$@) + $(call MSG_TOOL,xsltproc $(notdir $(firstword $(filter %.xsl,$^))),,$(filter %.xml,$^),$(patsubst %.ts,%,$@)) + $(QUIET)$(APPEND) -tn "$@" \ + '/* Autogenerated by $<, do not edit! */' \ + '' \ + '#include "VBoxManageBuiltInHelp.h"' \ + '' + $(foreach refentry,$(filter %.xml,$^) \ + ,$(NLTAB)$(QUIET)$(call VBOX_XSLTPROC_WITH_CAT, -a+to "$@") $< $(refentry)) + $(QUIET)$(APPEND) -n "$@" \ + '' \ + 'PCRTMSGREFENTRY g_apHelpEntries[] = ' \ + '{' + $(foreach refentry,$(filter %.xml,$^) \ + ,$(NLTAB)$(QUIET)$(APPEND) -n "$@" \ + ' &g_$(subst -,_,$(tolower $(patsubst man_%,%,$(notdir $(basename $(refentry)))))), ') + $(QUIET)$(APPEND) -n "$@" \ + '};' \ + 'const uint32_t g_cHelpEntries = RT_ELEMENTS(g_apHelpEntries);' \ + '' + $(QUIET)$(CP) --changed -- "$@" "$(patsubst %.ts,%,$@)" +# The above APPEND stuff trigger some kind of problem on some boxes when not split up... +# update: Fixed in SVN (strcpy -> memmove in new_job(), job.c - r2591). Just need to rebuild all platforms. + + +$(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.h.ts \ ++| $(VBoxManage_0_OUTDIR)/VBoxManageBuiltInHelp.h: \ + $(VBOX_DOCBOOK_REFENTRY_TO_H_HELP) \ + $(addprefix $(VBoxManage_0_OUTDIR)/,$(filter man_VBoxManage-%,$(VBOX_MANUAL_XML_REFENTRY_FILES))) \ + $(VBOX_XML_CATALOG) $(VBOX_XML_CATALOG_DOCBOOK) $(MAKEFILE) | $$(dir $$@) + $(call MSG_TOOL,xsltproc $(notdir $(firstword $(filter %.xsl,$^))),,$(filter %.xml,$^),$(patsubst %.ts,%,$@)) + $(QUIET)$(APPEND) -tn "$@" \ + '/* Autogenerated by $<, do not edit! */' \ + '' \ + '#ifndef ___VBoxManageBuiltInHelp_h___' \ + '#define ___VBoxManageBuiltInHelp_h___' \ + '' \ + '#include <iprt/message.h>' \ + '' \ + 'RT_C_DECLS_BEGIN' \ + '' \ + 'typedef enum HELP_CMD_VBOXMANAGE' \ + '{' \ + ' HELP_CMD_VBOXMANAGE_INVALID = 0,' + $(foreach refentry,$(filter %.xml,$^) \ + ,$(NLTAB)$(QUIET)$(call VBOX_XSLTPROC_WITH_CAT, -a+to "$@") \ + --stringparam 'g_sMode' 'cmd' $< $(refentry)) + $(QUIET)$(APPEND) -n "$@" \ + ' HELP_CMD_VBOXMANAGE_END' \ + '} HELP_CMD_VBOXMANAGE;' + $(foreach refentry,$(filter %.xml,$^) \ + ,$(NLTAB)$(QUIET)$(call VBOX_XSLTPROC_WITH_CAT, -a+to "$@") \ + --stringparam 'g_sMode' 'subcmd' $< $(refentry)) + $(QUIET)$(APPEND) -n "$@" \ + '' \ + 'extern PCRTMSGREFENTRY g_apHelpEntries[];' \ + 'extern const uint32_t g_cHelpEntries;' \ + '' \ + 'RT_C_DECLS_END' \ + '' \ + '#endif' \ + '' + $(QUIET)$(CP) --changed -- "$@" "$(patsubst %.ts,%,$@)" + + +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp b/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp new file mode 100644 index 00000000..9beaf9bc --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp @@ -0,0 +1,2597 @@ +/* $Id: VBoxInternalManage.cpp $ */ +/** @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-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> + +#include <VBox/com/VirtualBox.h> + +#include <VBox/vd.h> +#include <VBox/sup.h> +#include <VBox/log.h> + +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/getopt.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/uuid.h> +#include <iprt/sha.h> + +#include "VBoxManage.h" + +/* Includes for the raw disk stuff. */ +#ifdef RT_OS_WINDOWS +# include <iprt/win/windows.h> +# include <winioctl.h> +#elif defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) \ + || defined(RT_OS_SOLARIS) || defined(RT_OS_FREEBSD) +# include <errno.h> +# include <sys/ioctl.h> +# include <sys/types.h> +# include <sys/stat.h> +# include <fcntl.h> +# include <unistd.h> +#endif +#ifdef RT_OS_LINUX +# include <sys/utsname.h> +# include <linux/hdreg.h> +# include <linux/fs.h> +# include <stdlib.h> /* atoi() */ +#endif /* RT_OS_LINUX */ +#ifdef RT_OS_DARWIN +# include <sys/disk.h> +#endif /* RT_OS_DARWIN */ +#ifdef RT_OS_SOLARIS +# include <stropts.h> +# include <sys/dkio.h> +# include <sys/vtoc.h> +#endif /* RT_OS_SOLARIS */ +#ifdef RT_OS_FREEBSD +# include <sys/disk.h> +#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 + + +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; + +/** flag whether we're in internal mode */ +bool g_fInternalMode; + +/** + * Print the usage info. + */ +void printUsageInternal(USAGECATEGORY u64Cmd, PRTSTREAM pStrm) +{ + RTStrmPrintf(pStrm, + "Usage: VBoxManage internalcommands <command> [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 shall only be used to analyse\n" + " problems. It is completely unsupported and will change in\n" + " incompatible ways without warning.\n", + + (u64Cmd & USAGE_LOADMAP) + ? " loadmap <vmname|uuid> <symfile> <address> [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" + : "", + (u64Cmd & USAGE_LOADSYMS) + ? " loadsyms <vmname|uuid> <symfile> [delta] [module] [module address]\n" + " This will instruct DBGF to load the given symbol file\n" + " during initialization.\n" + "\n" + : "", + (u64Cmd & USAGE_SETHDUUID) + ? " sethduuid <filepath> [<uuid>]\n" + " Assigns a new UUID to the given image file. This way, multiple copies\n" + " of a container can be registered.\n" + "\n" + : "", + (u64Cmd & USAGE_SETHDPARENTUUID) + ? " sethdparentuuid <filepath> <uuid>\n" + " Assigns a new parent UUID to the given image file.\n" + "\n" + : "", + (u64Cmd & USAGE_DUMPHDINFO) + ? " dumphdinfo <filepath>\n" + " Prints information about the image at the given location.\n" + "\n" + : "", + (u64Cmd & USAGE_LISTPARTITIONS) + ? " listpartitions -rawdisk <diskname>\n" + " Lists all partitions on <diskname>.\n" + "\n" + : "", + (u64Cmd & USAGE_CREATERAWVMDK) + ? " createrawvmdk -filename <filename> -rawdisk <diskname>\n" + " [-partitions <list of partition numbers> [-mbr <filename>] ]\n" + " [-relative]\n" + " Creates a new VMDK image which gives access to an entire host disk (if\n" + " the parameter -partitions is not specified) or some partitions of a\n" + " host disk. If access to individual partitions is granted, then the\n" + " parameter -mbr can be used to specify an alternative MBR to be used\n" + " (the partitioning information in the MBR file is ignored).\n" + " The diskname is on Linux e.g. /dev/sda, and on Windows e.g.\n" + " \\\\.\\PhysicalDrive0).\n" + " On Linux or FreeBSD host the parameter -relative causes a VMDK file to\n" + " be created which refers to individual partitions instead to the entire\n" + " disk.\n" + " The necessary partition numbers can be queried with\n" + " VBoxManage internalcommands listpartitions\n" + "\n" + : "", + (u64Cmd & USAGE_RENAMEVMDK) + ? " renamevmdk -from <filename> -to <filename>\n" + " Renames an existing VMDK image, including the base file and all its extents.\n" + "\n" + : "", + (u64Cmd & USAGE_CONVERTTORAW) + ? " converttoraw [-format <fileformat>] <filename> <outputfile>" +#ifdef ENABLE_CONVERT_RAW_TO_STDOUT + "|stdout" +#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */ + "\n" + " Convert image to raw, writing to file" +#ifdef ENABLE_CONVERT_RAW_TO_STDOUT + " or stdout" +#endif /* ENABLE_CONVERT_RAW_TO_STDOUT */ + ".\n" + "\n" + : "", + (u64Cmd & USAGE_CONVERTHD) + ? " converthd [-srcformat VDI|VMDK|VHD|RAW]\n" + " [-dstformat VDI|VMDK|VHD|RAW]\n" + " <inputfile> <outputfile>\n" + " converts hard disk images between formats\n" + "\n" + : "", + (u64Cmd & USAGE_REPAIRHD) + ? " repairhd [-dry-run]\n" + " [-format VDI|VMDK|VHD|...]\n" + " <filename>\n" + " Tries to repair corrupted disk images\n" + "\n" + : "", +#ifdef RT_OS_WINDOWS + (u64Cmd & USAGE_MODINSTALL) + ? " modinstall\n" + " Installs the necessary driver for the host OS\n" + "\n" + : "", + (u64Cmd & USAGE_MODUNINSTALL) + ? " moduninstall\n" + " Deinstalls the driver\n" + "\n" + : "", +#else + "", + "", +#endif + (u64Cmd & USAGE_DEBUGLOG) + ? " debuglog <vmname|uuid> [--enable|--disable] [--flags todo]\n" + " [--groups todo] [--destinations todo]\n" + " Controls debug logging.\n" + "\n" + : "", + (u64Cmd & USAGE_PASSWORDHASH) + ? " passwordhash <passsword>\n" + " Generates a password hash.\n" + "\n" + : "", + (u64Cmd & USAGE_GUESTSTATS) + ? " gueststats <vmname|uuid> [--interval <seconds>]\n" + " Obtains and prints internal guest statistics.\n" + " Sets the update interval if specified.\n" + "\n" + : "" + ); +} + +/** @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<IMachine> 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("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<IMachine> 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 rc = RTUtf16ToUtf8(Keys.raw(), &pszKeys); + if (RT_SUCCESS(rc)) + { + /* 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("Failed to delete key '%s' from '%s', string conversion error %Rrc!", + pszKey, pszKeyBase, rc); + + 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<IMachine> 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("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<IMachine> 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<IMachine> 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<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + RT_NOREF(aSession); + HRESULT rc; + + /* + * Get the VM + */ + ComPtr<IMachine> 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("Missing the filename argument!\n"); + pszFilename = argv[1]; + + /* offDelta */ + if (argc >= 3) + { + int irc = RTStrToInt64Ex(argv[2], NULL, 0, &offDelta); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read delta '%s', rc=%Rrc\n", argv[2], rc); + } + + /* pszModule */ + if (argc >= 4) + pszModule = argv[3]; + + /* ModuleAddress */ + if (argc >= 5) + { + int irc = RTStrToUInt64Ex(argv[4], NULL, 0, &ModuleAddress); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[4], rc); + } + + /* ModuleSize */ + if (argc >= 6) + { + int irc = RTStrToUInt64Ex(argv[5], NULL, 0, &ModuleSize); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read module size '%s', rc=%Rrc\n", argv[5], rc); + } + + /* + * Add extra data. + */ + Utf8Str KeyStr; + HRESULT 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<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + RT_NOREF(aSession); + HRESULT rc; + + /* + * Get the VM + */ + ComPtr<IMachine> 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("Missing the filename argument!\n"); + pszFilename = argv[1]; + + /* address */ + if (argc < 3) + return errorArgument("Missing the module address argument!\n"); + int irc = RTStrToUInt64Ex(argv[2], NULL, 0, &ModuleAddress); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read module address '%s', rc=%Rrc\n", argv[2], rc); + + /* name (optional) */ + if (argc > 3) + pszModule = argv[3]; + + /* subtrahend (optional) */ + if (argc > 4) + { + irc = RTStrToUInt64Ex(argv[4], NULL, 0, &offSubtrahend); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read subtrahend '%s', rc=%Rrc\n", argv[4], rc); + } + + /* segment (optional) */ + if (argc > 5) + { + irc = RTStrToUInt32Ex(argv[5], NULL, 0, &iSeg); + if (RT_FAILURE(irc)) + return errorArgument(argv[0], "Failed to read segment number '%s', rc=%Rrc\n", argv[5], rc); + } + + /* + * Add extra data. + */ + Utf8Str KeyStr; + HRESULT 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 rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) +{ + RT_NOREF(pvUser); + RTMsgErrorV(pszFormat, va); + RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, 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<IVirtualBox> aVirtualBox, ComPtr<ISession> 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 errorSyntax(USAGE_SETHDUUID, "Not enough parameters"); + /* if specified, take UUID, otherwise generate a new one */ + if (argc == 3) + { + if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2]))) + return errorSyntax(USAGE_SETHDUUID, "Invalid UUID parameter"); + uuid = argv[2]; + } else + uuid.create(); + } + else if (!strcmp(argv[0], "sethdparentuuid")) + { + uuidType = HDPARENTUUID; + if (argc != 3) + return errorSyntax(USAGE_SETHDPARENTUUID, "Not enough parameters"); + if (RT_FAILURE(RTUuidFromStr(&rtuuid, argv[2]))) + return errorSyntax(USAGE_SETHDPARENTUUID, "Invalid UUID parameter"); + uuid = argv[2]; + } + else + return errorSyntax(USAGE_SETHDUUID, "Invalid invocation"); + + /* just try it */ + char *pszFormat = NULL; + VDTYPE enmType = VDTYPE_INVALID; + int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, + argv[1], &pszFormat, &enmType); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc); + + PVDISK pDisk = NULL; + + PVDINTERFACE pVDIfs = NULL; + VDINTERFACEERROR vdInterfaceError; + vdInterfaceError.pfnError = handleVDError; + vdInterfaceError.pfnMessage = handleVDMessage; + + rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, + NULL, sizeof(VDINTERFACEERROR), &pVDIfs); + AssertRC(rc); + + rc = VDCreate(pVDIfs, enmType, &pDisk); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc); + + /* Open the image */ + rc = VDOpen(pDisk, pszFormat, argv[1], VD_OPEN_FLAGS_NORMAL | VD_OPEN_FLAGS_INFO, NULL); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc); + + if (uuidType == HDUUID) + rc = VDSetUuid(pDisk, VD_LAST_IMAGE, uuid.raw()); + else + rc = VDSetParentUuid(pDisk, VD_LAST_IMAGE, uuid.raw()); + if (RT_FAILURE(rc)) + RTMsgError("Cannot set a new UUID: %Rrc", rc); + else + RTPrintf("UUID changed to: %s\n", uuid.toString().c_str()); + + VDCloseAll(pDisk); + + return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +static RTEXITCODE CmdDumpHDInfo(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + RT_NOREF(aVirtualBox, aSession); + + /* we need exactly one parameter: the image file */ + if (argc != 1) + { + return errorSyntax(USAGE_DUMPHDINFO, "Not enough parameters"); + } + + /* just try it */ + char *pszFormat = NULL; + VDTYPE enmType = VDTYPE_INVALID; + int rc = VDGetFormat(NULL /* pVDIfsDisk */, NULL /* pVDIfsImage */, + argv[0], &pszFormat, &enmType); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Format autodetect failed: %Rrc", rc); + + PVDISK pDisk = NULL; + + PVDINTERFACE pVDIfs = NULL; + VDINTERFACEERROR vdInterfaceError; + vdInterfaceError.pfnError = handleVDError; + vdInterfaceError.pfnMessage = handleVDMessage; + + rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, + NULL, sizeof(VDINTERFACEERROR), &pVDIfs); + AssertRC(rc); + + rc = VDCreate(pVDIfs, enmType, &pDisk); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot create the virtual disk container: %Rrc", rc); + + /* Open the image */ + rc = VDOpen(pDisk, pszFormat, argv[0], VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO, NULL); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open the image: %Rrc", rc); + + VDDumpImages(pDisk); + + VDCloseAll(pDisk); + + return RT_SUCCESS(rc) ? 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; + int rc; + + VDISKPARTTYPE partitioningType; + + pPart->cPartitions = 0; + memset(pPart->aPartitions, '\0', sizeof(pPart->aPartitions)); + + rc = RTFileReadAt(File, 0, &aBuffer, sizeof(aBuffer), NULL); + if (RT_FAILURE(rc)) + return rc; + + if (aBuffer[450] == 0xEE)/* check the sign of the GPT disk*/ + { + partitioningType = GPT; + pPart->uPartitioningType = GPT;//partitioningType; + + if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa) + return VERR_INVALID_PARAMETER; + + rc = RTFileReadAt(File, sector_size, &partitionTableHeader, sector_size, NULL); + if (RT_SUCCESS(rc)) + { + /** @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("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("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. */ + rc = RTFileReadAt(File, 1024, pbPartTable, RT_ALIGN_Z(partitionEntrySize * partitionsNumber, 512), NULL); + if (RT_FAILURE(rc)) + { + RTMsgError("Reading the partition table failed"); + RTMemFree(pbPartTable); + return rc; + } + + 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 = MBR; + pPart->uPartitioningType = 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("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("Inconsistency for logical partition start"); + return VERR_INVALID_PARAMETER; + } + + do + { + rc = RTFileReadAt(File, (uStart + uOffset) * 512, &aBuffer, sizeof(aBuffer), NULL); + if (RT_FAILURE(rc)) + return rc; + + if (aBuffer[510] != 0x55 || aBuffer[511] != 0xaa) + { + RTMsgError("Logical partition without magic"); + return VERR_INVALID_PARAMETER; + } + uint8_t *p = &aBuffer[0x1be]; + + if (p[4] == 0) + { + RTMsgError("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("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("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("Two partitions start at the same place"); + return VERR_INVALID_PARAMETER; + } + else if (pPart->aPartitions[j].uStart == 0) + { + RTMsgError("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 == 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("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("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<IVirtualBox> aVirtualBox, ComPtr<ISession> 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("Missing argument to '%s'", argv[i]); + } + i++; + rawdisk = argv[i]; + } + else + { + return errorSyntax(USAGE_LISTPARTITIONS, "Invalid parameter '%s'", argv[i]); + } + } + + if (rawdisk.isEmpty()) + return errorSyntax(USAGE_LISTPARTITIONS, "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, "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("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 PVDISKRAWPARTDESC appendPartDesc(uint32_t *pcPartDescs, PVDISKRAWPARTDESC *ppPartDescs) +{ + (*pcPartDescs)++; + PVDISKRAWPARTDESC p; + p = (PVDISKRAWPARTDESC)RTMemRealloc(*ppPartDescs, + *pcPartDescs * sizeof(VDISKRAWPARTDESC)); + *ppPartDescs = p; + if (p) + { + p = p + *pcPartDescs - 1; + memset(p, '\0', sizeof(VDISKRAWPARTDESC)); + } + + return p; +} + +static RTEXITCODE CmdCreateRawVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + RT_NOREF(aVirtualBox, aSession); + HRESULT rc = S_OK; + Utf8Str filename; + const char *pszMBRFilename = NULL; + Utf8Str rawdisk; + const char *pszPartitions = NULL; + bool fRelative = false; + + uint64_t cbSize = 0; + PVDISK pDisk = NULL; + VDISKRAW RawDescriptor; + PVDINTERFACE pVDIfs = NULL; + + /* let's have a closer look at the arguments */ + for (int i = 0; i < argc; i++) + { + if (strcmp(argv[i], "-filename") == 0) + { + if (argc <= i + 1) + { + return errorArgument("Missing argument to '%s'", argv[i]); + } + i++; + filename = argv[i]; + } + else if (strcmp(argv[i], "-mbr") == 0) + { + if (argc <= i + 1) + { + return errorArgument("Missing argument to '%s'", argv[i]); + } + i++; + pszMBRFilename = argv[i]; + } + else if (strcmp(argv[i], "-rawdisk") == 0) + { + if (argc <= i + 1) + { + return errorArgument("Missing argument to '%s'", argv[i]); + } + i++; + rawdisk = argv[i]; + } + else if (strcmp(argv[i], "-partitions") == 0) + { + if (argc <= i + 1) + { + return errorArgument("Missing argument to '%s'", argv[i]); + } + i++; + pszPartitions = argv[i]; + } +#if defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD) || defined(RT_OS_WINDOWS) + else if (strcmp(argv[i], "-relative") == 0) + { + fRelative = true; + } +#endif /* RT_OS_LINUX || RT_OS_FREEBSD */ + else + return errorSyntax(USAGE_CREATERAWVMDK, "Invalid parameter '%s'", argv[i]); + } + + if (filename.isEmpty()) + return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -filename missing"); + if (rawdisk.isEmpty()) + return errorSyntax(USAGE_CREATERAWVMDK, "Mandatory parameter -rawdisk missing"); + if (!pszPartitions && pszMBRFilename) + return errorSyntax(USAGE_CREATERAWVMDK, "The parameter -mbr is only valid when the parameter -partitions is also present"); + +#ifdef RT_OS_DARWIN + fRelative = true; +#endif /* RT_OS_DARWIN */ + RTFILE hRawFile; + int vrc = RTFileOpen(&hRawFile, rawdisk.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot open the raw disk '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + +#ifdef RT_OS_WINDOWS + /* Windows NT has no IOCTL_DISK_GET_LENGTH_INFORMATION ioctl. This was + * added to Windows XP, so we have to use the available info from DriveGeo. + * Note that we cannot simply use IOCTL_DISK_GET_DRIVE_GEOMETRY as it + * yields a slightly different result than IOCTL_DISK_GET_LENGTH_INFO. + * We call IOCTL_DISK_GET_DRIVE_GEOMETRY first as we need to check the media + * type anyway, and if IOCTL_DISK_GET_LENGTH_INFORMATION is supported + * we will later override cbSize. + */ + DISK_GEOMETRY DriveGeo; + DWORD cbDriveGeo; + if (DeviceIoControl((HANDLE)RTFileToNative(hRawFile), + IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, + &DriveGeo, sizeof(DriveGeo), &cbDriveGeo, NULL)) + { + if ( DriveGeo.MediaType == FixedMedia + || DriveGeo.MediaType == RemovableMedia) + { + cbSize = DriveGeo.Cylinders.QuadPart + * DriveGeo.TracksPerCylinder + * DriveGeo.SectorsPerTrack + * DriveGeo.BytesPerSector; + } + else + { + RTMsgError("File '%s' is no fixed/removable medium device", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + + GET_LENGTH_INFORMATION DiskLenInfo; + DWORD junk; + if (DeviceIoControl((HANDLE)RTFileToNative(hRawFile), + IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, + &DiskLenInfo, sizeof(DiskLenInfo), &junk, (LPOVERLAPPED)NULL)) + { + /* IOCTL_DISK_GET_LENGTH_INFO is supported -- override cbSize. */ + cbSize = DiskLenInfo.Length.QuadPart; + } + if ( fRelative + && !rawdisk.startsWith("\\\\.\\PhysicalDrive", Utf8Str::CaseInsensitive)) + { + RTMsgError("The -relative parameter is invalid for raw disk %s", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + /* + * Could be raw image, remember error code and try to get the size first + * before failing. + */ + vrc = RTErrConvertFromWin32(GetLastError()); + if (RT_FAILURE(RTFileGetSize(hRawFile, &cbSize))) + { + RTMsgError("Cannot get the geometry of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + else + { + if (fRelative) + { + RTMsgError("The -relative parameter is invalid for raw images"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + vrc = VINF_SUCCESS; + } + } +#elif defined(RT_OS_LINUX) + struct stat DevStat; + if (!fstat(RTFileToNative(hRawFile), &DevStat)) + { + if (S_ISBLK(DevStat.st_mode)) + { +#ifdef BLKGETSIZE64 + /* BLKGETSIZE64 is broken up to 2.4.17 and in many 2.5.x. In 2.6.0 + * it works without problems. */ + struct utsname utsname; + if ( uname(&utsname) == 0 + && ( (strncmp(utsname.release, "2.5.", 4) == 0 && atoi(&utsname.release[4]) >= 18) + || (strncmp(utsname.release, "2.", 2) == 0 && atoi(&utsname.release[2]) >= 6))) + { + uint64_t cbBlk; + if (!ioctl(RTFileToNative(hRawFile), BLKGETSIZE64, &cbBlk)) + cbSize = cbBlk; + } +#endif /* BLKGETSIZE64 */ + if (!cbSize) + { + long cBlocks; + if (!ioctl(RTFileToNative(hRawFile), BLKGETSIZE, &cBlocks)) + cbSize = (uint64_t)cBlocks << 9; + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + } + else if (S_ISREG(DevStat.st_mode)) + { + vrc = RTFileGetSize(hRawFile, &cbSize); + if (RT_FAILURE(vrc)) + { + RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + else if (fRelative) + { + RTMsgError("The -relative parameter is invalid for raw images"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + RTMsgError("File '%s' is no block device", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc", + rawdisk.c_str(), vrc); + } +#elif defined(RT_OS_DARWIN) + struct stat DevStat; + if (!fstat(RTFileToNative(hRawFile), &DevStat)) + { + if (S_ISBLK(DevStat.st_mode)) + { + uint64_t cBlocks; + uint32_t cbBlock; + if (!ioctl(RTFileToNative(hRawFile), DKIOCGETBLOCKCOUNT, &cBlocks)) + { + if (!ioctl(RTFileToNative(hRawFile), DKIOCGETBLOCKSIZE, &cbBlock)) + cbSize = cBlocks * cbBlock; + else + { + RTMsgError("Cannot get the block size for file '%s': %Rrc", rawdisk.c_str(), vrc); + vrc = RTErrConvertFromErrno(errno); + goto out; + } + } + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + else if (S_ISREG(DevStat.st_mode)) + { + fRelative = false; /* Must be false for raw image files. */ + vrc = RTFileGetSize(hRawFile, &cbSize); + if (RT_FAILURE(vrc)) + { + RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + else + { + RTMsgError("File '%s' is neither block device nor regular file", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc", + rawdisk.c_str(), vrc); + } +#elif defined(RT_OS_SOLARIS) + struct stat DevStat; + if (!fstat(RTFileToNative(hRawFile), &DevStat)) + { + if (S_ISBLK(DevStat.st_mode) || S_ISCHR(DevStat.st_mode)) + { + struct dk_minfo mediainfo; + if (!ioctl(RTFileToNative(hRawFile), DKIOCGMEDIAINFO, &mediainfo)) + cbSize = mediainfo.dki_capacity * mediainfo.dki_lbsize; + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + else if (S_ISREG(DevStat.st_mode)) + { + vrc = RTFileGetSize(hRawFile, &cbSize); + if (RT_FAILURE(vrc)) + { + RTMsgError("Failed to get size of file '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + else + { + RTMsgError("File '%s' is no block or char device", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc", + rawdisk.c_str(), vrc); + } +#elif defined(RT_OS_FREEBSD) + struct stat DevStat; + if (!fstat(RTFileToNative(hRawFile), &DevStat)) + { + if (S_ISCHR(DevStat.st_mode)) + { + off_t cbMedia = 0; + if (!ioctl(RTFileToNative(hRawFile), DIOCGMEDIASIZE, &cbMedia)) + cbSize = cbMedia; + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Cannot get the block count for file '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + } + else if (S_ISREG(DevStat.st_mode)) + { + if (fRelative) + { + RTMsgError("The -relative parameter is invalid for raw images"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + cbSize = DevStat.st_size; + } + else + { + RTMsgError("File '%s' is neither character device nor regular file", rawdisk.c_str()); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + else + { + vrc = RTErrConvertFromErrno(errno); + RTMsgError("Failed to get file informtation for raw disk '%s': %Rrc", + rawdisk.c_str(), vrc); + } +#else /* all unrecognized OSes */ + /* Hopefully this works on all other hosts. If it doesn't, it'll just fail + * creating the VMDK, so no real harm done. */ + vrc = RTFileGetSize(hRawFile, &cbSize); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot get the size of the raw disk '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } +#endif + + /* Check whether cbSize is actually sensible. */ + if (!cbSize || cbSize % 512) + { + RTMsgError("Detected size of raw disk '%s' is %RU64, an invalid value", rawdisk.c_str(), cbSize); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + + RawDescriptor.szSignature[0] = 'R'; + RawDescriptor.szSignature[1] = 'A'; + RawDescriptor.szSignature[2] = 'W'; + RawDescriptor.szSignature[3] = '\0'; + if (!pszPartitions) + { + RawDescriptor.uFlags = VDISKRAW_DISK; + RawDescriptor.pszRawDisk = rawdisk.c_str(); + } + else + { + RawDescriptor.uFlags = VDISKRAW_NORMAL; + RawDescriptor.pszRawDisk = NULL; + RawDescriptor.cPartDescs = 0; + RawDescriptor.pPartDescs = NULL; + + uint32_t uPartitions = 0; + uint32_t uPartitionsRO = 0; + + const char *p = pszPartitions; + char *pszNext; + uint32_t u32; + while (*p != '\0') + { + vrc = RTStrToUInt32Ex(p, &pszNext, 0, &u32); + if (RT_FAILURE(vrc)) + { + RTMsgError("Incorrect value in partitions parameter"); + goto out; + } + uPartitions |= RT_BIT(u32); + p = pszNext; + if (*p == 'r') + { + uPartitionsRO |= RT_BIT(u32); + p++; + } + if (*p == ',') + p++; + else if (*p != '\0') + { + RTMsgError("Incorrect separator in partitions parameter"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + + HOSTPARTITIONS partitions; + vrc = partRead(hRawFile, &partitions); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot read the partition information from '%s'", rawdisk.c_str()); + goto out; + } + + RawDescriptor.uPartitioningType = partitions.uPartitioningType; + + for (unsigned i = 0; i < partitions.cPartitions; i++) + { + if ( uPartitions & RT_BIT(partitions.aPartitions[i].uIndex) + && PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType)) + { + /* Some ignorant user specified an extended partition. + * Bad idea, as this would trigger an overlapping + * partitions error later during VMDK creation. So warn + * here and ignore what the user requested. */ + RTMsgWarning("It is not possible (and necessary) to explicitly give access to the " + "extended partition %u. If required, enable access to all logical " + "partitions inside this extended partition.", + partitions.aPartitions[i].uIndex); + uPartitions &= ~RT_BIT(partitions.aPartitions[i].uIndex); + } + } + + for (unsigned i = 0; i < partitions.cPartitions; i++) + { + PVDISKRAWPARTDESC pPartDesc = NULL; + + /* first dump the MBR/EPT data area */ + if (partitions.aPartitions[i].cPartDataSectors) + { + pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs, + &RawDescriptor.pPartDescs); + if (!pPartDesc) + { + RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str()); + vrc = VERR_NO_MEMORY; + goto out; + } + + /** @todo the clipping below isn't 100% accurate, as it should + * actually clip to the track size. However, that's easier said + * than done as figuring out the track size is heuristics. In + * any case the clipping is adjusted later after sorting, to + * prevent overlapping data areas on the resulting image. */ + pPartDesc->cbData = RT_MIN(partitions.aPartitions[i].cPartDataSectors, 63) * 512; + pPartDesc->uStart = partitions.aPartitions[i].uPartDataStart * 512; + Assert(pPartDesc->cbData - (size_t)pPartDesc->cbData == 0); + void *pPartData = RTMemAlloc((size_t)pPartDesc->cbData); + if (!pPartData) + { + RTMsgError("Out of memory allocating the partition descriptor for '%s'", rawdisk.c_str()); + vrc = VERR_NO_MEMORY; + goto out; + } + vrc = RTFileReadAt(hRawFile, partitions.aPartitions[i].uPartDataStart * 512, + pPartData, (size_t)pPartDesc->cbData, NULL); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot read partition data from raw device '%s': %Rrc", rawdisk.c_str(), vrc); + goto out; + } + /* Splice in the replacement MBR code if specified. */ + if ( partitions.aPartitions[i].uPartDataStart == 0 + && pszMBRFilename) + { + RTFILE MBRFile; + vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot open replacement MBR file '%s' specified with -mbr: %Rrc", pszMBRFilename, vrc); + goto out; + } + vrc = RTFileReadAt(MBRFile, 0, pPartData, 0x1be, NULL); + RTFileClose(MBRFile); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot read replacement MBR file '%s': %Rrc", pszMBRFilename, vrc); + goto out; + } + } + pPartDesc->pvPartitionData = pPartData; + } + + if (PARTTYPE_IS_EXTENDED(partitions.aPartitions[i].uType)) + { + /* Suppress exporting the actual extended partition. Only + * logical partitions should be processed. However completely + * ignoring it leads to leaving out the EBR data. */ + continue; + } + + /* set up values for non-relative device names */ + const char *pszRawName = rawdisk.c_str(); + uint64_t uStartOffset = partitions.aPartitions[i].uStart * 512; + + pPartDesc = appendPartDesc(&RawDescriptor.cPartDescs, + &RawDescriptor.pPartDescs); + if (!pPartDesc) + { + RTMsgError("Out of memory allocating the partition list for '%s'", rawdisk.c_str()); + vrc = VERR_NO_MEMORY; + goto out; + } + + if (uPartitions & RT_BIT(partitions.aPartitions[i].uIndex)) + { + if (uPartitionsRO & RT_BIT(partitions.aPartitions[i].uIndex)) + pPartDesc->uFlags |= VDISKRAW_READONLY; + + if (fRelative) + { +#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD) + /* Refer to the correct partition and use offset 0. */ + char *psz; +#if defined(RT_OS_LINUX) + /* + * Check whether raw disk ends with a digit. In that case + * insert a p before adding the partition number. + * This is used for nvme devices only currently which look like + * /dev/nvme0n1p1 but might be extended to other devices in the + * future. + */ + size_t cchRawDisk = rawdisk.length(); + if (RT_C_IS_DIGIT(pszRawName[cchRawDisk - 1])) + RTStrAPrintf(&psz, + "%sp%u", + rawdisk.c_str(), + partitions.aPartitions[i].uIndex); + else + RTStrAPrintf(&psz, + "%s%u", + rawdisk.c_str(), + partitions.aPartitions[i].uIndex); +#elif defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD) + RTStrAPrintf(&psz, + "%ss%u", + rawdisk.c_str(), + partitions.aPartitions[i].uIndex); +#endif + if (!psz) + { + vrc = VERR_NO_STR_MEMORY; + RTMsgError("Cannot create reference to individual partition %u, rc=%Rrc", + partitions.aPartitions[i].uIndex, vrc); + goto out; + } + pszRawName = psz; + uStartOffset = 0; +#elif defined(RT_OS_WINDOWS) + /* Refer to the correct partition and use offset 0. */ + char *psz; + RTStrAPrintf(&psz, "\\\\.\\Harddisk%sPartition%u", + rawdisk.c_str() + 17, + partitions.aPartitions[i].uIndexWin); + if (!psz) + { + vrc = VERR_NO_STR_MEMORY; + RTMsgError("Cannot create reference to individual partition %u (numbered %u), rc=%Rrc", + partitions.aPartitions[i].uIndex, partitions.aPartitions[i].uIndexWin, vrc); + goto out; + } + pszRawName = psz; + uStartOffset = 0; +#else + /** @todo not implemented for other hosts. Treat just like + * not specified (this code is actually never reached). */ +#endif + } + + pPartDesc->pszRawDevice = pszRawName; + pPartDesc->uStartOffset = uStartOffset; + } + else + { + pPartDesc->pszRawDevice = NULL; + pPartDesc->uStartOffset = 0; + } + + pPartDesc->uStart = partitions.aPartitions[i].uStart * 512; + pPartDesc->cbData = partitions.aPartitions[i].uSize * 512; + } + + /* Sort data areas in ascending order of start. */ + for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++) + { + unsigned uMinIdx = i; + uint64_t uMinVal = RawDescriptor.pPartDescs[i].uStart; + for (unsigned j = i + 1; j < RawDescriptor.cPartDescs; j++) + { + if (RawDescriptor.pPartDescs[j].uStart < uMinVal) + { + uMinIdx = j; + uMinVal = RawDescriptor.pPartDescs[j].uStart; + } + } + if (uMinIdx != i) + { + /* Swap entries at index i and uMinIdx. */ + VDISKRAWPARTDESC tmp; + memcpy(&tmp, &RawDescriptor.pPartDescs[i], sizeof(tmp)); + memcpy(&RawDescriptor.pPartDescs[i], &RawDescriptor.pPartDescs[uMinIdx], sizeof(tmp)); + memcpy(&RawDescriptor.pPartDescs[uMinIdx], &tmp, sizeof(tmp)); + } + } + + /* Have a second go at MBR/EPT, GPT area clipping. Now that the data areas + * are sorted this is much easier to get 100% right. */ + //for (unsigned i = 0; i < RawDescriptor.cPartDescs-1; i++) + for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++) + { + if (RawDescriptor.pPartDescs[i].pvPartitionData) + { + RawDescriptor.pPartDescs[i].cbData = RT_MIN(RawDescriptor.pPartDescs[i+1].uStart - RawDescriptor.pPartDescs[i].uStart, RawDescriptor.pPartDescs[i].cbData); + if (!RawDescriptor.pPartDescs[i].cbData) + { + if (RawDescriptor.uPartitioningType == MBR) + { + RTMsgError("MBR/EPT overlaps with data area"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + else + { + if (RawDescriptor.cPartDescs != i+1) + { + RTMsgError("GPT overlaps with data area"); + vrc = VERR_INVALID_PARAMETER; + goto out; + } + } + } + } + } + } + + RTFileClose(hRawFile); + +#ifdef DEBUG_klaus + if (!(RawDescriptor.uFlags & VDISKRAW_DISK)) + { + RTPrintf("# start length startoffset partdataptr device\n"); + for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++) + { + RTPrintf("%2u %14RU64 %14RU64 %14RU64 %#18p %s\n", i, + RawDescriptor.pPartDescs[i].uStart, + RawDescriptor.pPartDescs[i].cbData, + RawDescriptor.pPartDescs[i].uStartOffset, + RawDescriptor.pPartDescs[i].pvPartitionData, + RawDescriptor.pPartDescs[i].pszRawDevice); + } + } +#endif + + VDINTERFACEERROR vdInterfaceError; + vdInterfaceError.pfnError = handleVDError; + vdInterfaceError.pfnMessage = handleVDMessage; + + rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, + NULL, sizeof(VDINTERFACEERROR), &pVDIfs); + AssertRC(vrc); + + vrc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); /* Raw VMDK's are harddisk only. */ + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot create the virtual disk container: %Rrc", vrc); + goto out; + } + + Assert(RT_MIN(cbSize / 512 / 16 / 63, 16383) - + (unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383) == 0); + VDGEOMETRY PCHS, LCHS; + PCHS.cCylinders = (unsigned int)RT_MIN(cbSize / 512 / 16 / 63, 16383); + PCHS.cHeads = 16; + PCHS.cSectors = 63; + LCHS.cCylinders = 0; + LCHS.cHeads = 0; + LCHS.cSectors = 0; + vrc = VDCreateBase(pDisk, "VMDK", filename.c_str(), cbSize, + VD_IMAGE_FLAGS_FIXED | VD_VMDK_IMAGE_FLAGS_RAWDISK, + (char *)&RawDescriptor, &PCHS, &LCHS, NULL, + VD_OPEN_FLAGS_NORMAL, NULL, NULL); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot create the raw disk VMDK: %Rrc", vrc); + goto out; + } + RTPrintf("RAW host disk access VMDK file %s created successfully.\n", filename.c_str()); + + VDCloseAll(pDisk); + + /* Clean up allocated memory etc. */ + if (pszPartitions) + { + for (unsigned i = 0; i < RawDescriptor.cPartDescs; i++) + { + /* Free memory allocated for relative device name. */ + if (fRelative && RawDescriptor.pPartDescs[i].pszRawDevice) + RTStrFree((char *)(void *)RawDescriptor.pPartDescs[i].pszRawDevice); + if (RawDescriptor.pPartDescs[i].pvPartitionData) + RTMemFree((void *)RawDescriptor.pPartDescs[i].pvPartitionData); + } + if (RawDescriptor.pPartDescs) + RTMemFree(RawDescriptor.pPartDescs); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; + +out: + RTMsgError("The raw disk vmdk file was not created"); + return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static RTEXITCODE CmdRenameVMDK(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> 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("Missing argument to '%s'", argv[i]); + } + i++; + src = argv[i]; + } + else if (strcmp(argv[i], "-to") == 0) + { + if (argc <= i + 1) + { + return errorArgument("Missing argument to '%s'", argv[i]); + } + i++; + dst = argv[i]; + } + else + { + return errorSyntax(USAGE_RENAMEVMDK, "Invalid parameter '%s'", argv[i]); + } + } + + if (src.isEmpty()) + return errorSyntax(USAGE_RENAMEVMDK, "Mandatory parameter -from missing"); + if (dst.isEmpty()) + return errorSyntax(USAGE_RENAMEVMDK, "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, "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("Cannot rename the image: %Rrc", vrc); + } + else + RTMsgError("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<IVirtualBox> aVirtualBox, ComPtr<ISession> 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("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 errorSyntax(USAGE_CONVERTTORAW, "Invalid parameter '%s'", argv[i]); + } + } + + if (src.isEmpty()) + return errorSyntax(USAGE_CONVERTTORAW, "Mandatory filename parameter missing"); + if (dst.isEmpty()) + return errorSyntax(USAGE_CONVERTTORAW, "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, "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, "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(), &pszFormat, &enmType); + if (RT_FAILURE(vrc) || enmType != VDTYPE_HDD) + { + VDCloseAll(pDisk); + if (!fWriteToStdOut) + { + RTFileClose(outFile); + RTFileDelete(dst.c_str()); + } + if (RT_FAILURE(vrc)) + RTMsgError("No file format specified and autodetect failed - please specify format: %Rrc", vrc); + else + RTMsgError("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, "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, "Converting image \"%s\" with size %RU64 bytes (%RU64MB) to raw...\n", 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, "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, "Out of memory allocating read buffer"); + } + + if (!fWriteToStdOut) + RTFileClose(outFile); + VDCloseAll(pDisk); + return RTEXITCODE_SUCCESS; +} + +static RTEXITCODE CmdConvertHardDisk(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> 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("Missing argument to '%s'", argv[i]); + } + i++; + srcformat = argv[i]; + } + else if (strcmp(argv[i], "-dstformat") == 0) + { + if (argc <= i + 1) + { + return errorArgument("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 errorSyntax(USAGE_CONVERTHD, "Invalid parameter '%s'", argv[i]); + } + } + + if (src.isEmpty()) + return errorSyntax(USAGE_CONVERTHD, "Mandatory input image parameter missing"); + if (dst.isEmpty()) + return errorSyntax(USAGE_CONVERTHD, "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(), &pszFormat, &enmSrcType); + if (RT_FAILURE(vrc)) + { + RTMsgError("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("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("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("Cannot create the destination virtual disk container: %Rrc", vrc); + break; + } + + uint64_t cbSize = VDGetSize(pSrcDisk, VD_LAST_IMAGE); + RTStrmPrintf(g_pStdErr, "Converting image \"%s\" with size %RU64 bytes (%RU64MB)...\n", 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("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<IVirtualBox> aVirtualBox, ComPtr<ISession> 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("Missing argument to '%s'", argv[i]); + } + i++; + format = argv[i]; + } + else if (image.isEmpty()) + { + image = argv[i]; + } + else + { + return errorSyntax(USAGE_REPAIRHD, "Invalid parameter '%s'", argv[i]); + } + } + + if (image.isEmpty()) + return errorSyntax(USAGE_REPAIRHD, "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(), &pszFormat, &enmSrcType); + if (RT_FAILURE(vrc) && (vrc != VERR_VD_IMAGE_CORRUPTED)) + { + RTMsgError("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 rc = SUPR3Uninstall(); + if (RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED) + return RTEXITCODE_SUCCESS; + return RTEXITCODE_FAILURE; +} + +/** + * Loads the necessary driver. + * + * @returns VBox status code + */ +static RTEXITCODE CmdModInstall(void) +{ + int rc = SUPR3Install(); + if (RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED) + return RTEXITCODE_SUCCESS; + return RTEXITCODE_FAILURE; +} + +static RTEXITCODE CmdDebugLog(int argc, char **argv, ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> 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 errorSyntax(USAGE_DEBUGLOG, "Missing VM name/UUID"); + + ComPtr<IMachine> ptrMachine; + HRESULT rc; + 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<IConsole> ptrConsole; + CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IMachineDebugger> 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 errorGetOpt(USAGE_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("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<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + RT_NOREF(aVirtualBox, aSession); + + /* one parameter, the password to hash */ + if (argc != 1) + return errorSyntax(USAGE_PASSWORDHASH, "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("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<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession) +{ + /* one parameter, guest name */ + if (argc < 1) + return errorSyntax(USAGE_GUESTSTATS, "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 errorGetOpt(USAGE_GUESTSTATS, ch, &ValueUnion); + } + } + + if (argc > 1 && aUpdateInterval == 0) + return errorSyntax(USAGE_GUESTSTATS, "Invalid update interval specified"); + + RTPrintf("argc=%d interval=%u\n", argc, aUpdateInterval); + + ComPtr<IMachine> ptrMachine; + HRESULT rc; + 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<IConsole> ptrConsole; + CHECK_ERROR_RET(aSession, COMGETTER(Console)(ptrConsole.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IGuest> 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) +{ + g_fInternalMode = true; + + /* at least a command is required */ + if (a->argc < 1) + return errorSyntax(USAGE_ALL, "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->virtualBox, a->session); + 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 errorSyntax(USAGE_ALL, "Invalid command '%s'", a->argv[0]); +} + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManage.cpp b/src/VBox/Frontends/VBoxManage/VBoxManage.cpp new file mode 100644 index 00000000..fe3fcffe --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManage.cpp @@ -0,0 +1,760 @@ +/* $Id: VBoxManage.cpp $ */ +/** @file + * VBoxManage - VirtualBox's command-line interface. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +# include <VBox/com/com.h> +# include <VBox/com/string.h> +# include <VBox/com/Guid.h> +# include <VBox/com/array.h> +# include <VBox/com/ErrorInfo.h> +# include <VBox/com/errorprint.h> +# include <VBox/com/NativeEventQueue.h> + +# include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <VBox/version.h> + +#include <iprt/asm.h> +#include <iprt/buildconfig.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/getopt.h> +#include <iprt/initterm.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> + +#include <signal.h> + +#include "VBoxManage.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The command doesn't need the COM stuff. */ +#define VBMG_CMD_F_NO_COM RT_BIT_32(0) + +#define VBMG_CMD_TODO HELP_CMD_VBOXMANAGE_INVALID + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +/** + * VBoxManage command descriptor. + */ +typedef struct VBMGCMD +{ + /** The command. */ + const char *pszCommand; + /** The help category. */ + USAGECATEGORY enmHelpCat; + /** The new help command. */ + enum HELP_CMD_VBOXMANAGE enmCmdHelp; + /** The handler. */ + RTEXITCODE (*pfnHandler)(HandlerArg *pArg); + /** VBMG_CMD_F_XXX, */ + uint32_t fFlags; +} VBMGCMD; +/** Pointer to a const VBoxManage command descriptor. */ +typedef VBMGCMD const *PCVBMGCMD; +#endif + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/*extern*/ bool g_fDetailedProgress = false; + +#ifndef VBOX_ONLY_DOCS +/** Set by the signal handler. */ +static volatile bool g_fCanceled = false; + + +/** + * All registered command handlers + */ +static const VBMGCMD g_aCommands[] = +{ + { "internalcommands", 0, VBMG_CMD_TODO, handleInternalCommands, 0 }, + { "list", USAGE_LIST, VBMG_CMD_TODO, handleList, 0 }, + { "showvminfo", USAGE_SHOWVMINFO, VBMG_CMD_TODO, handleShowVMInfo, 0 }, + { "registervm", USAGE_REGISTERVM, VBMG_CMD_TODO, handleRegisterVM, 0 }, + { "unregistervm", USAGE_UNREGISTERVM, VBMG_CMD_TODO, handleUnregisterVM, 0 }, + { "clonevm", USAGE_CLONEVM, VBMG_CMD_TODO, handleCloneVM, 0 }, + { "movevm", USAGE_MOVEVM, VBMG_CMD_TODO, handleMoveVM, 0 }, + { "mediumproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, + { "hdproperty", USAGE_MEDIUMPROPERTY, VBMG_CMD_TODO, handleMediumProperty, 0 }, /* backward compatibility */ + { "createmedium", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, + { "createhd", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */ + { "createvdi", USAGE_CREATEMEDIUM, VBMG_CMD_TODO, handleCreateMedium, 0 }, /* backward compatibility */ + { "modifymedium", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, + { "modifyhd", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */ + { "modifyvdi", USAGE_MODIFYMEDIUM, VBMG_CMD_TODO, handleModifyMedium, 0 }, /* backward compatibility */ + { "clonemedium", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, + { "clonehd", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */ + { "clonevdi", USAGE_CLONEMEDIUM, VBMG_CMD_TODO, handleCloneMedium, 0 }, /* backward compatibility */ + { "encryptmedium", USAGE_ENCRYPTMEDIUM, VBMG_CMD_TODO, handleEncryptMedium, 0 }, + { "checkmediumpwd", USAGE_MEDIUMENCCHKPWD, VBMG_CMD_TODO, handleCheckMediumPassword, 0 }, + { "createvm", USAGE_CREATEVM, VBMG_CMD_TODO, handleCreateVM, 0 }, + { "modifyvm", USAGE_MODIFYVM, VBMG_CMD_TODO, handleModifyVM, 0 }, + { "startvm", USAGE_STARTVM, VBMG_CMD_TODO, handleStartVM, 0 }, + { "controlvm", USAGE_CONTROLVM, VBMG_CMD_TODO, handleControlVM, 0 }, + { "unattended", USAGE_UNATTENDED, HELP_CMD_UNATTENDED, handleUnattended, 0 }, + { "discardstate", USAGE_DISCARDSTATE, VBMG_CMD_TODO, handleDiscardState, 0 }, + { "adoptstate", USAGE_ADOPTSTATE, VBMG_CMD_TODO, handleAdoptState, 0 }, + { "snapshot", USAGE_SNAPSHOT, VBMG_CMD_TODO, handleSnapshot, 0 }, + { "closemedium", USAGE_CLOSEMEDIUM, VBMG_CMD_TODO, handleCloseMedium, 0 }, + { "storageattach", USAGE_STORAGEATTACH, VBMG_CMD_TODO, handleStorageAttach, 0 }, + { "storagectl", USAGE_STORAGECONTROLLER,VBMG_CMD_TODO, handleStorageController, 0 }, + { "showmediuminfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, + { "showhdinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */ + { "showvdiinfo", USAGE_SHOWMEDIUMINFO, VBMG_CMD_TODO, handleShowMediumInfo, 0 }, /* backward compatibility */ + { "mediumio", USAGE_MEDIUMIO, HELP_CMD_MEDIUMIO, handleMediumIO, 0 }, + { "getextradata", USAGE_GETEXTRADATA, VBMG_CMD_TODO, handleGetExtraData, 0 }, + { "setextradata", USAGE_SETEXTRADATA, VBMG_CMD_TODO, handleSetExtraData, 0 }, + { "setproperty", USAGE_SETPROPERTY, VBMG_CMD_TODO, handleSetProperty, 0 }, + { "usbfilter", USAGE_USBFILTER, VBMG_CMD_TODO, handleUSBFilter, 0 }, + { "sharedfolder", USAGE_SHAREDFOLDER, VBMG_CMD_TODO, handleSharedFolder, 0 }, +#ifdef VBOX_WITH_GUEST_PROPS + { "guestproperty", USAGE_GUESTPROPERTY, VBMG_CMD_TODO, handleGuestProperty, 0 }, +#endif +#ifdef VBOX_WITH_GUEST_CONTROL + { "guestcontrol", USAGE_GUESTCONTROL, VBMG_CMD_TODO, handleGuestControl, 0 }, +#endif + { "metrics", USAGE_METRICS, VBMG_CMD_TODO, handleMetrics, 0 }, + { "import", USAGE_IMPORTAPPLIANCE, VBMG_CMD_TODO, handleImportAppliance, 0 }, + { "export", USAGE_EXPORTAPPLIANCE, VBMG_CMD_TODO, handleExportAppliance, 0 }, +#ifdef VBOX_WITH_NETFLT + { "hostonlyif", USAGE_HOSTONLYIFS, VBMG_CMD_TODO, handleHostonlyIf, 0 }, +#endif + { "dhcpserver", USAGE_DHCPSERVER, VBMG_CMD_TODO, handleDHCPServer, 0 }, +#ifdef VBOX_WITH_NAT_SERVICE + { "natnetwork", USAGE_NATNETWORK, VBMG_CMD_TODO, handleNATNetwork, 0 }, +#endif + { "extpack", USAGE_EXTPACK, HELP_CMD_EXTPACK, handleExtPack, 0 }, + { "bandwidthctl", USAGE_BANDWIDTHCONTROL, VBMG_CMD_TODO, handleBandwidthControl, 0 }, + { "debugvm", USAGE_DEBUGVM, HELP_CMD_DEBUGVM, handleDebugVM, 0 }, + { "convertfromraw", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM }, + { "convertdd", USAGE_CONVERTFROMRAW, VBMG_CMD_TODO, handleConvertFromRaw, VBMG_CMD_F_NO_COM }, + { "usbdevsource", USAGE_USBDEVSOURCE, VBMG_CMD_TODO, handleUSBDevSource, 0 } +}; + + +/** + * Looks up a command by name. + * + * @returns Pointer to the command structure. + * @param pszCommand Name of the command. + */ +static PCVBMGCMD lookupCommand(const char *pszCommand) +{ + if (pszCommand) + for (uint32_t i = 0; i < RT_ELEMENTS(g_aCommands); i++) + if (!strcmp(g_aCommands[i].pszCommand, pszCommand)) + return &g_aCommands[i]; + return NULL; +} + + +/** + * Signal handler that sets g_fCanceled. + * + * This can be executed on any thread in the process, on Windows it may even be + * a thread dedicated to delivering this signal. Do not doing anything + * unnecessary here. + */ +static void showProgressSignalHandler(int iSignal) +{ + NOREF(iSignal); + ASMAtomicWriteBool(&g_fCanceled, true); +} + +/** + * Print out progress on the console. + * + * This runs the main event queue every now and then to prevent piling up + * unhandled things (which doesn't cause real problems, just makes things + * react a little slower than in the ideal case). + */ +HRESULT showProgress(ComPtr<IProgress> progress) +{ + using namespace com; + + BOOL fCompleted = FALSE; + ULONG ulCurrentPercent = 0; + ULONG ulLastPercent = 0; + + ULONG ulLastOperationPercent = (ULONG)-1; + + ULONG ulLastOperation = (ULONG)-1; + Bstr bstrOperationDescription; + + NativeEventQueue::getMainEventQueue()->processEventQueue(0); + + ULONG cOperations = 1; + HRESULT hrc = progress->COMGETTER(OperationCount)(&cOperations); + if (FAILED(hrc)) + { + RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc); + RTStrmFlush(g_pStdErr); + return hrc; + } + + /* + * Note: Outputting the progress info to stderr (g_pStdErr) is intentional + * to not get intermixed with other (raw) stdout data which might get + * written in the meanwhile. + */ + + if (!g_fDetailedProgress) + { + RTStrmPrintf(g_pStdErr, "0%%..."); + RTStrmFlush(g_pStdErr); + } + + /* setup signal handling if cancelable */ + bool fCanceledAlready = false; + BOOL fCancelable; + hrc = progress->COMGETTER(Cancelable)(&fCancelable); + if (FAILED(hrc)) + fCancelable = FALSE; + if (fCancelable) + { + signal(SIGINT, showProgressSignalHandler); + signal(SIGTERM, showProgressSignalHandler); +#ifdef SIGBREAK + signal(SIGBREAK, showProgressSignalHandler); +#endif + } + + hrc = progress->COMGETTER(Completed(&fCompleted)); + while (SUCCEEDED(hrc)) + { + progress->COMGETTER(Percent(&ulCurrentPercent)); + + if (g_fDetailedProgress) + { + ULONG ulOperation = 1; + hrc = progress->COMGETTER(Operation)(&ulOperation); + if (FAILED(hrc)) + break; + ULONG ulCurrentOperationPercent = 0; + hrc = progress->COMGETTER(OperationPercent(&ulCurrentOperationPercent)); + if (FAILED(hrc)) + break; + + if (ulLastOperation != ulOperation) + { + hrc = progress->COMGETTER(OperationDescription(bstrOperationDescription.asOutParam())); + if (FAILED(hrc)) + break; + ulLastPercent = (ULONG)-1; // force print + ulLastOperation = ulOperation; + } + + if ( ulCurrentPercent != ulLastPercent + || ulCurrentOperationPercent != ulLastOperationPercent + ) + { + LONG lSecsRem = 0; + progress->COMGETTER(TimeRemaining)(&lSecsRem); + + RTStrmPrintf(g_pStdErr, "(%u/%u) %ls %02u%% => %02u%% (%d s remaining)\n", ulOperation + 1, cOperations, + bstrOperationDescription.raw(), ulCurrentOperationPercent, ulCurrentPercent, lSecsRem); + ulLastPercent = ulCurrentPercent; + ulLastOperationPercent = ulCurrentOperationPercent; + } + } + else + { + /* did we cross a 10% mark? */ + if (ulCurrentPercent / 10 > ulLastPercent / 10) + { + /* make sure to also print out missed steps */ + for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10) + { + if (curVal < 100) + { + RTStrmPrintf(g_pStdErr, "%u%%...", curVal); + RTStrmFlush(g_pStdErr); + } + } + ulLastPercent = (ulCurrentPercent / 10) * 10; + } + } + if (fCompleted) + break; + + /* process async cancelation */ + if (g_fCanceled && !fCanceledAlready) + { + hrc = progress->Cancel(); + if (SUCCEEDED(hrc)) + fCanceledAlready = true; + else + g_fCanceled = false; + } + + /* make sure the loop is not too tight */ + progress->WaitForCompletion(100); + + NativeEventQueue::getMainEventQueue()->processEventQueue(0); + hrc = progress->COMGETTER(Completed(&fCompleted)); + } + + /* undo signal handling */ + if (fCancelable) + { + signal(SIGINT, SIG_DFL); + signal(SIGTERM, SIG_DFL); +# ifdef SIGBREAK + signal(SIGBREAK, SIG_DFL); +# endif + } + + /* complete the line. */ + LONG iRc = E_FAIL; + hrc = progress->COMGETTER(ResultCode)(&iRc); + if (SUCCEEDED(hrc)) + { + if (SUCCEEDED(iRc)) + RTStrmPrintf(g_pStdErr, "100%%\n"); + else if (g_fCanceled) + RTStrmPrintf(g_pStdErr, "CANCELED\n"); + else + { + if (!g_fDetailedProgress) + RTStrmPrintf(g_pStdErr, "\n"); + RTStrmPrintf(g_pStdErr, "Progress state: %Rhrc\n", iRc); + } + hrc = iRc; + } + else + { + if (!g_fDetailedProgress) + RTStrmPrintf(g_pStdErr, "\n"); + RTStrmPrintf(g_pStdErr, "Progress object failure: %Rhrc\n", hrc); + } + RTStrmFlush(g_pStdErr); + return hrc; +} + +RTEXITCODE readPasswordFile(const char *pszFilename, com::Utf8Str *pPasswd) +{ + size_t cbFile; + char szPasswd[512]; + int vrc = VINF_SUCCESS; + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + bool fStdIn = !strcmp(pszFilename, "stdin"); + PRTSTREAM pStrm; + if (!fStdIn) + vrc = RTStrmOpen(pszFilename, "r", &pStrm); + else + pStrm = g_pStdIn; + if (RT_SUCCESS(vrc)) + { + vrc = RTStrmReadEx(pStrm, szPasswd, sizeof(szPasswd)-1, &cbFile); + if (RT_SUCCESS(vrc)) + { + if (cbFile >= sizeof(szPasswd)-1) + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Provided password in file '%s' is too long", pszFilename); + else + { + unsigned i; + for (i = 0; i < cbFile && !RT_C_IS_CNTRL(szPasswd[i]); i++) + ; + szPasswd[i] = '\0'; + *pPasswd = szPasswd; + } + } + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot read password from file '%s': %Rrc", pszFilename, vrc); + if (!fStdIn) + RTStrmClose(pStrm); + } + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot open password file '%s' (%Rrc)", pszFilename, vrc); + + return rcExit; +} + +static RTEXITCODE settingsPasswordFile(ComPtr<IVirtualBox> virtualBox, const char *pszFilename) +{ + com::Utf8Str passwd; + RTEXITCODE rcExit = readPasswordFile(pszFilename, &passwd); + if (rcExit == RTEXITCODE_SUCCESS) + { + CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(com::Bstr(passwd).raw()), rcExit = RTEXITCODE_FAILURE); + } + + return rcExit; +} + +RTEXITCODE readPasswordFromConsole(com::Utf8Str *pPassword, const char *pszPrompt, ...) +{ + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + char aszPwdInput[_1K] = { 0 }; + va_list vaArgs; + + va_start(vaArgs, pszPrompt); + int vrc = RTStrmPrintfV(g_pStdOut, pszPrompt, vaArgs); + if (RT_SUCCESS(vrc)) + { + bool fEchoOld = false; + vrc = RTStrmInputGetEchoChars(g_pStdIn, &fEchoOld); + if (RT_SUCCESS(vrc)) + { + vrc = RTStrmInputSetEchoChars(g_pStdIn, false); + if (RT_SUCCESS(vrc)) + { + vrc = RTStrmGetLine(g_pStdIn, &aszPwdInput[0], sizeof(aszPwdInput)); + if (RT_SUCCESS(vrc)) + *pPassword = aszPwdInput; + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed read password from command line (%Rrc)", vrc); + + int vrc2 = RTStrmInputSetEchoChars(g_pStdIn, fEchoOld); + AssertRC(vrc2); + } + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to disable echoing typed characters (%Rrc)", vrc); + } + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to retrieve echo setting (%Rrc)", vrc); + + RTStrmPutStr(g_pStdOut, "\n"); + } + else + rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to print prompt (%Rrc)", vrc); + va_end(vaArgs); + + return rcExit; +} + +#endif /* !VBOX_ONLY_DOCS */ + + +int main(int argc, char *argv[]) +{ + /* + * Before we do anything, init the runtime without loading + * the support driver. + */ + int vrc = RTR3InitExe(argc, &argv, 0); + if (RT_FAILURE(vrc)) + return RTMsgInitFailure(vrc); +#if defined(RT_OS_WINDOWS) && !defined(VBOX_ONLY_DOCS) + ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */ +#endif + + /* + * Parse the global options + */ + bool fShowLogo = false; + bool fShowHelp = false; + int iCmd = 1; + int iCmdArg; + const char *pszSettingsPw = NULL; + const char *pszSettingsPwFile = NULL; +#ifndef VBOX_ONLY_DOCS + int cResponseFileArgs = 0; + char **papszResponseFileArgs = NULL; + char **papszNewArgv = NULL; +#endif + + for (int i = 1; i < argc || argc <= iCmd; i++) + { + if ( argc <= iCmd + || !strcmp(argv[i], "help") + || !strcmp(argv[i], "--help") + || !strcmp(argv[i], "-?") + || !strcmp(argv[i], "-h") + || !strcmp(argv[i], "-help")) + { + if (i >= argc - 1) + { + showLogo(g_pStdOut); + printUsage(USAGE_ALL, ~0U, g_pStdOut); + return 0; + } + fShowLogo = true; + fShowHelp = true; + iCmd++; + continue; + } + +#ifndef VBOX_ONLY_DOCS + if ( !strcmp(argv[i], "-V") + || !strcmp(argv[i], "--version") + || !strcmp(argv[i], "-v") /* deprecated */ + || !strcmp(argv[i], "-version") /* deprecated */ + || !strcmp(argv[i], "-Version") /* deprecated */) + { + /* Print version number, and do nothing else. */ + RTPrintf("%sr%u\n", VBOX_VERSION_STRING, RTBldCfgRevision()); + return 0; + } +#endif + + if ( !strcmp(argv[i], "--dumpopts") + || !strcmp(argv[i], "-dumpopts") /* deprecated */) + { + /* Special option to dump really all commands, + * even the ones not understood on this platform. */ + printUsage(USAGE_DUMPOPTS, ~0U, g_pStdOut); + return 0; + } + + if ( !strcmp(argv[i], "--nologo") + || !strcmp(argv[i], "-q") + || !strcmp(argv[i], "-nologo") /* deprecated */) + { + /* suppress the logo */ + fShowLogo = false; + iCmd++; + } + else if ( !strcmp(argv[i], "--detailed-progress") + || !strcmp(argv[i], "-d")) + { + /* detailed progress report */ + g_fDetailedProgress = true; + iCmd++; + } + else if (!strcmp(argv[i], "--settingspw")) + { + if (i >= argc - 1) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Password expected"); + /* password for certain settings */ + pszSettingsPw = argv[i + 1]; + iCmd += 2; + } + else if (!strcmp(argv[i], "--settingspwfile")) + { + if (i >= argc-1) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "No password file specified"); + pszSettingsPwFile = argv[i+1]; + iCmd += 2; + } +#ifndef VBOX_ONLY_DOCS + else if (argv[i][0] == '@') + { + if (papszResponseFileArgs) + return RTMsgErrorExitFailure("Only one response file allowed"); + + /* Load response file, making sure it's valid UTF-8. */ + char *pszResponseFile; + size_t cbResponseFile; + vrc = RTFileReadAllEx(&argv[i][1], 0, RTFOFF_MAX, RTFILE_RDALL_O_DENY_NONE | RTFILE_RDALL_F_TRAILING_ZERO_BYTE, + (void **)&pszResponseFile, &cbResponseFile); + if (RT_FAILURE(vrc)) + return RTMsgErrorExitFailure("Error reading response file '%s': %Rrc", &argv[i][1], vrc); + vrc = RTStrValidateEncoding(pszResponseFile); + if (RT_FAILURE(vrc)) + { + RTFileReadAllFree(pszResponseFile, cbResponseFile); + return RTMsgErrorExitFailure("Invalid response file ('%s') encoding: %Rrc", &argv[i][1], vrc); + } + + /* Parse it. */ + vrc = RTGetOptArgvFromString(&papszResponseFileArgs, &cResponseFileArgs, pszResponseFile, + RTGETOPTARGV_CNV_QUOTE_BOURNE_SH, NULL); + RTFileReadAllFree(pszResponseFile, cbResponseFile); + if (RT_FAILURE(vrc)) + return RTMsgErrorExitFailure("Failed to parse response file '%s' (bourne shell style): %Rrc", &argv[i][1], vrc); + + /* Construct new argv+argc with the response file arguments inserted. */ + int cNewArgs = argc + cResponseFileArgs; + papszNewArgv = (char **)RTMemAllocZ((cNewArgs + 2) * sizeof(papszNewArgv[0])); + if (!papszNewArgv) + return RTMsgErrorExitFailure("out of memory"); + memcpy(&papszNewArgv[0], &argv[0], sizeof(argv[0]) * (i + 1)); + memcpy(&papszNewArgv[i + 1], papszResponseFileArgs, sizeof(argv[0]) * cResponseFileArgs); + memcpy(&papszNewArgv[i + 1 + cResponseFileArgs], &argv[i + 1], sizeof(argv[0]) * (argc - i - 1 + 1)); + argv = papszNewArgv; + argc = argc + cResponseFileArgs; + + iCmd++; + } +#endif + else + break; + } + + iCmdArg = iCmd + 1; + + /* + * Show the logo and lookup the command and deal with fShowHelp = true. + */ + if (fShowLogo) + showLogo(g_pStdOut); + +#ifndef VBOX_ONLY_DOCS + PCVBMGCMD pCmd = lookupCommand(argv[iCmd]); + if (pCmd && pCmd->enmCmdHelp != VBMG_CMD_TODO) + setCurrentCommand(pCmd->enmCmdHelp); + + if ( pCmd + && ( fShowHelp + || ( argc - iCmdArg == 0 + && pCmd->enmHelpCat != 0))) + { + if (pCmd->enmCmdHelp == VBMG_CMD_TODO) + printUsage(pCmd->enmHelpCat, ~0U, g_pStdOut); + else if (fShowHelp) + printHelp(g_pStdOut); + else + printUsage(g_pStdOut); + return RTEXITCODE_FAILURE; /* error */ + } + if (!pCmd) + { + if (!strcmp(argv[iCmd], "commands")) + { + RTPrintf("commands:\n"); + for (unsigned i = 0; i < RT_ELEMENTS(g_aCommands); i++) + if ( i == 0 /* skip backwards compatibility entries */ + || g_aCommands[i].enmHelpCat != g_aCommands[i - 1].enmHelpCat) + RTPrintf(" %s\n", g_aCommands[i].pszCommand); + return RTEXITCODE_SUCCESS; + } + return errorSyntax(USAGE_ALL, "Invalid command '%s'", argv[iCmd]); + } + + RTEXITCODE rcExit; + if (!(pCmd->fFlags & VBMG_CMD_F_NO_COM)) + { + /* + * Initialize COM. + */ + using namespace com; + HRESULT hrc = com::Initialize(); + if (FAILED(hrc)) + { +# ifdef VBOX_WITH_XPCOM + if (hrc == NS_ERROR_FILE_ACCESS_DENIED) + { + char szHome[RTPATH_MAX] = ""; + com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome)); + return RTMsgErrorExit(RTEXITCODE_FAILURE, + "Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome); + } +# endif + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize COM! (hrc=%Rhrc)", hrc); + } + + + /* + * Get the remote VirtualBox object and create a local session object. + */ + rcExit = RTEXITCODE_FAILURE; + ComPtr<IVirtualBoxClient> virtualBoxClient; + ComPtr<IVirtualBox> virtualBox; + hrc = virtualBoxClient.createInprocObject(CLSID_VirtualBoxClient); + if (SUCCEEDED(hrc)) + hrc = virtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam()); + if (SUCCEEDED(hrc)) + { + ComPtr<ISession> session; + hrc = session.createInprocObject(CLSID_Session); + if (SUCCEEDED(hrc)) + { + /* Session secret. */ + if (pszSettingsPw) + CHECK_ERROR2I_STMT(virtualBox, SetSettingsSecret(Bstr(pszSettingsPw).raw()), rcExit = RTEXITCODE_FAILURE); + else if (pszSettingsPwFile) + rcExit = settingsPasswordFile(virtualBox, pszSettingsPwFile); + else + rcExit = RTEXITCODE_SUCCESS; + if (rcExit == RTEXITCODE_SUCCESS) + { + /* + * Call the handler. + */ + HandlerArg handlerArg = { argc - iCmdArg, &argv[iCmdArg], virtualBox, session }; + rcExit = pCmd->pfnHandler(&handlerArg); + + /* Although all handlers should always close the session if they open it, + * we do it here just in case if some of the handlers contains a bug -- + * leaving the direct session not closed will turn the machine state to + * Aborted which may have unwanted side effects like killing the saved + * state file (if the machine was in the Saved state before). */ + session->UnlockMachine(); + } + + NativeEventQueue::getMainEventQueue()->processEventQueue(0); + } + else + { + com::ErrorInfo info; + RTMsgError("Failed to create a session object!"); + if (!info.isFullAvailable() && !info.isBasicAvailable()) + com::GluePrintRCMessage(hrc); + else + com::GluePrintErrorInfo(info); + } + } + else + { + com::ErrorInfo info; + RTMsgError("Failed to create the VirtualBox object!"); + if (!info.isFullAvailable() && !info.isBasicAvailable()) + { + com::GluePrintRCMessage(hrc); + RTMsgError("Most likely, the VirtualBox COM server is not running or failed to start."); + } + else + com::GluePrintErrorInfo(info); + } + + /* + * Terminate COM, make sure the virtualBox object has been released. + */ + virtualBox.setNull(); + virtualBoxClient.setNull(); + NativeEventQueue::getMainEventQueue()->processEventQueue(0); + com::Shutdown(); + } + else + { + /* + * The command needs no COM. + */ + HandlerArg handlerArg; + handlerArg.argc = argc - iCmdArg; + handlerArg.argv = &argv[iCmdArg]; + rcExit = pCmd->pfnHandler(&handlerArg); + } + + if (papszResponseFileArgs) + { + RTGetOptArgvFree(papszResponseFileArgs); + RTMemFree(papszNewArgv); + } + + return rcExit; +#else /* VBOX_ONLY_DOCS */ + return RTEXITCODE_SUCCESS; +#endif /* VBOX_ONLY_DOCS */ +} diff --git a/src/VBox/Frontends/VBoxManage/VBoxManage.h b/src/VBox/Frontends/VBoxManage/VBoxManage.h new file mode 100644 index 00000000..e1d619ae --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManage.h @@ -0,0 +1,338 @@ +/* $Id: VBoxManage.h $ */ +/** @file + * VBoxManage - VirtualBox command-line interface, internal header file. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxManage_VBoxManage_h +#define VBOX_INCLUDED_SRC_VBoxManage_VBoxManage_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#ifndef VBOX_ONLY_DOCS +#include <VBox/com/com.h> +#include <VBox/com/ptr.h> +#include <VBox/com/VirtualBox.h> +#include <VBox/com/string.h> +#include <VBox/com/array.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/types.h> +#include <iprt/message.h> +#include <iprt/stream.h> +#include <iprt/getopt.h> + +#ifndef VBOX_ONLY_DOCS +# include "VBoxManageBuiltInHelp.h" +#endif + + +//////////////////////////////////////////////////////////////////////////////// +// +// definitions +// +//////////////////////////////////////////////////////////////////////////////// + +/** @name Syntax diagram category. + * @{ */ +#define USAGE_DUMPOPTS 0 +#define USAGE_LIST RT_BIT_64(0) +#define USAGE_SHOWVMINFO RT_BIT_64(1) +#define USAGE_REGISTERVM RT_BIT_64(2) +#define USAGE_UNREGISTERVM RT_BIT_64(3) +#define USAGE_CREATEVM RT_BIT_64(4) +#define USAGE_MODIFYVM RT_BIT_64(5) +#define USAGE_CLONEVM RT_BIT_64(6) +#define USAGE_STARTVM RT_BIT_64(7) +#define USAGE_CONTROLVM RT_BIT_64(8) +#define USAGE_DISCARDSTATE RT_BIT_64(9) +#define USAGE_SNAPSHOT RT_BIT_64(10) +#define USAGE_CLOSEMEDIUM RT_BIT_64(11) +#define USAGE_SHOWMEDIUMINFO RT_BIT_64(12) +#define USAGE_CREATEMEDIUM RT_BIT_64(13) +#define USAGE_MODIFYMEDIUM RT_BIT_64(14) +#define USAGE_CLONEMEDIUM RT_BIT_64(15) +#define USAGE_MOVEVM RT_BIT_64(16) +#define USAGE_CREATEHOSTIF RT_BIT_64(17) +#define USAGE_REMOVEHOSTIF RT_BIT_64(18) +#define USAGE_GETEXTRADATA RT_BIT_64(19) +#define USAGE_SETEXTRADATA RT_BIT_64(20) +#define USAGE_SETPROPERTY RT_BIT_64(21) +#define USAGE_USBFILTER (RT_BIT_64(22) | RT_BIT_64(23) | RT_BIT_64(24)) +#define USAGE_USBFILTER_ADD RT_BIT_64(22) +#define USAGE_USBFILTER_MODIFY RT_BIT_64(23) +#define USAGE_USBFILTER_REMOVE RT_BIT_64(24) +#define USAGE_SHAREDFOLDER (RT_BIT_64(25) | RT_BIT_64(26)) +#define USAGE_SHAREDFOLDER_ADD RT_BIT_64(25) +#define USAGE_SHAREDFOLDER_REMOVE RT_BIT_64(26) +#define USAGE_UNATTENDED RT_BIT_64(27) +#define USAGE_MEDIUMIO RT_BIT_64(28) +#define USAGE_LOADSYMS RT_BIT_64(29) +#define USAGE_LOADMAP RT_BIT_64(30) +#define USAGE_SETHDUUID RT_BIT_64(31) +#define USAGE_CONVERTFROMRAW RT_BIT_64(32) +#define USAGE_LISTPARTITIONS RT_BIT_64(33) +#define USAGE_CREATERAWVMDK RT_BIT_64(34) +#define USAGE_DEBUGVM RT_BIT_64(35) +#define USAGE_ADOPTSTATE RT_BIT_64(36) +#define USAGE_MODINSTALL RT_BIT_64(37) +#define USAGE_MODUNINSTALL RT_BIT_64(38) +#define USAGE_RENAMEVMDK RT_BIT_64(39) +#ifdef VBOX_WITH_GUEST_PROPS +# define USAGE_GUESTPROPERTY RT_BIT_64(40) +#endif /* VBOX_WITH_GUEST_PROPS defined */ +#define USAGE_CONVERTTORAW RT_BIT_64(41) +#define USAGE_METRICS RT_BIT_64(42) +#define USAGE_CONVERTHD RT_BIT_64(43) +#define USAGE_IMPORTAPPLIANCE RT_BIT_64(44) +#define USAGE_EXPORTAPPLIANCE RT_BIT_64(45) +#define USAGE_HOSTONLYIFS RT_BIT_64(46) +#define USAGE_DHCPSERVER RT_BIT_64(47) +#define USAGE_DUMPHDINFO RT_BIT_64(48) +#define USAGE_STORAGEATTACH RT_BIT_64(49) +#define USAGE_STORAGECONTROLLER RT_BIT_64(50) +#ifdef VBOX_WITH_GUEST_CONTROL +# define USAGE_GUESTCONTROL RT_BIT_64(51) +#endif /* VBOX_WITH_GUEST_CONTROL defined */ +#define USAGE_DEBUGLOG RT_BIT_64(52) +#define USAGE_SETHDPARENTUUID RT_BIT_64(53) +#define USAGE_PASSWORDHASH RT_BIT_64(54) +#define USAGE_EXTPACK RT_BIT_64(55) +#define USAGE_BANDWIDTHCONTROL RT_BIT_64(56) +#define USAGE_GUESTSTATS RT_BIT_64(57) +#define USAGE_REPAIRHD RT_BIT_64(58) +#define USAGE_NATNETWORK RT_BIT_64(59) +#define USAGE_MEDIUMPROPERTY RT_BIT_64(60) +#define USAGE_ENCRYPTMEDIUM RT_BIT_64(61) +#define USAGE_MEDIUMENCCHKPWD RT_BIT_64(62) +#define USAGE_USBDEVSOURCE RT_BIT_64(63) +#define USAGE_ALL (~(uint64_t)0) +/** @} */ + +#ifdef VBOX_WITH_GUEST_CONTROL +# define USAGE_GSTCTRL_RUN RT_BIT(0) +# define USAGE_GSTCTRL_START RT_BIT(1) +# define USAGE_GSTCTRL_COPYFROM RT_BIT(2) +# define USAGE_GSTCTRL_COPYTO RT_BIT(3) +# define USAGE_GSTCTRL_MKDIR RT_BIT(4) +# define USAGE_GSTCTRL_RMDIR RT_BIT(5) +# define USAGE_GSTCTRL_RM RT_BIT(6) +# define USAGE_GSTCTRL_MV RT_BIT(7) +# define USAGE_GSTCTRL_MKTEMP RT_BIT(8) +# define USAGE_GSTCTRL_LIST RT_BIT(9) +# define USAGE_GSTCTRL_CLOSEPROCESS RT_BIT(10) +# define USAGE_GSTCTRL_CLOSESESSION RT_BIT(11) +# define USAGE_GSTCTRL_STAT RT_BIT(12) +# define USAGE_GSTCTRL_UPDATEGA RT_BIT(13) +# define USAGE_GSTCTRL_WATCH RT_BIT(14) +#endif + + +typedef uint64_t USAGECATEGORY; + +/** command handler argument */ +struct HandlerArg +{ + int argc; + char **argv; + +#ifndef VBOX_ONLY_DOCS + ComPtr<IVirtualBox> virtualBox; + ComPtr<ISession> session; +#endif +}; + +/** flag whether we're in internal mode */ +extern bool g_fInternalMode; + +/** showVMInfo details */ +typedef enum +{ + VMINFO_NONE = 0, + VMINFO_STANDARD = 1, /**< standard details */ + VMINFO_FULL = 2, /**< both */ + VMINFO_MACHINEREADABLE = 3, /**< both, and make it machine readable */ + VMINFO_COMPACT = 4 +} VMINFO_DETAILS; + + +//////////////////////////////////////////////////////////////////////////////// +// +// global variables +// +//////////////////////////////////////////////////////////////////////////////// + +extern bool g_fDetailedProgress; // in VBoxManage.cpp + + +//////////////////////////////////////////////////////////////////////////////// +// +// prototypes +// +//////////////////////////////////////////////////////////////////////////////// + +/* VBoxManageHelp.cpp */ +void printUsage(USAGECATEGORY fCategory, uint32_t fSubCategory, PRTSTREAM pStrm); +RTEXITCODE errorSyntax(USAGECATEGORY fCategory, const char *pszFormat, ...); +RTEXITCODE errorSyntaxEx(USAGECATEGORY fCategory, uint32_t fSubCategory, const char *pszFormat, ...); +RTEXITCODE errorGetOpt(USAGECATEGORY fCategory, int rc, union RTGETOPTUNION const *pValueUnion); +RTEXITCODE errorGetOptEx(USAGECATEGORY fCategory, uint32_t fSubCategory, int rc, union RTGETOPTUNION const *pValueUnion); +RTEXITCODE errorArgument(const char *pszFormat, ...); + +void printUsageInternal(USAGECATEGORY fCategory, PRTSTREAM pStrm); + +#ifndef VBOX_ONLY_DOCS +void setCurrentCommand(enum HELP_CMD_VBOXMANAGE enmCommand); +void setCurrentSubcommand(uint64_t fCurSubcommandScope); + +void printUsage(PRTSTREAM pStrm); +void printHelp(PRTSTREAM pStrm); +RTEXITCODE errorNoSubcommand(void); +RTEXITCODE errorUnknownSubcommand(const char *pszSubCmd); +RTEXITCODE errorTooManyParameters(char **papszArgs); +RTEXITCODE errorGetOpt(int rcGetOpt, union RTGETOPTUNION const *pValueUnion); +RTEXITCODE errorSyntax(const char *pszFormat, ...); + +HRESULT showProgress(ComPtr<IProgress> progress); +#endif + +/* VBoxManage.cpp */ +void showLogo(PRTSTREAM pStrm); + +#ifndef VBOX_ONLY_DOCS +RTEXITCODE readPasswordFile(const char *pszFilename, com::Utf8Str *pPasswd); +RTEXITCODE readPasswordFromConsole(com::Utf8Str *pPassword, const char *pszPrompt, ...); + +RTEXITCODE handleInternalCommands(HandlerArg *a); +#endif /* !VBOX_ONLY_DOCS */ + +/* VBoxManageControlVM.cpp */ +RTEXITCODE handleControlVM(HandlerArg *a); +#ifndef VBOX_ONLY_DOCS +unsigned int getMaxNics(IVirtualBox* vbox, IMachine* mach); +#endif + +/* VBoxManageModifyVM.cpp */ +#ifndef VBOX_ONLY_DOCS +void parseGroups(const char *pcszGroups, com::SafeArray<BSTR> *pGroups); +#endif +RTEXITCODE handleModifyVM(HandlerArg *a); + +/* VBoxManageDebugVM.cpp */ +RTEXITCODE handleDebugVM(HandlerArg *a); + +/* VBoxManageGuestProp.cpp */ +extern void usageGuestProperty(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2); + +/* VBoxManageGuestCtrl.cpp */ +extern void usageGuestControl(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2, uint32_t fSubCategory); + +#ifndef VBOX_ONLY_DOCS +/* VBoxManageGuestProp.cpp */ +RTEXITCODE handleGuestProperty(HandlerArg *a); + +/* VBoxManageGuestCtrl.cpp */ +RTEXITCODE handleGuestControl(HandlerArg *a); + +/* VBoxManageVMInfo.cpp */ +HRESULT showSnapshots(ComPtr<ISnapshot> &rootSnapshot, + ComPtr<ISnapshot> ¤tSnapshot, + VMINFO_DETAILS details, + const com::Utf8Str &prefix = "", + int level = 0); +RTEXITCODE handleShowVMInfo(HandlerArg *a); +HRESULT showVMInfo(ComPtr<IVirtualBox> pVirtualBox, + ComPtr<IMachine> pMachine, + ComPtr<ISession> pSession, + VMINFO_DETAILS details = VMINFO_NONE); +const char *machineStateToName(MachineState_T machineState, bool fShort); +HRESULT showBandwidthGroups(ComPtr<IBandwidthControl> &bwCtrl, + VMINFO_DETAILS details); + +/* VBoxManageList.cpp */ +RTEXITCODE handleList(HandlerArg *a); + +/* VBoxManageMetrics.cpp */ +RTEXITCODE handleMetrics(HandlerArg *a); + +/* VBoxManageMisc.cpp */ +RTEXITCODE handleRegisterVM(HandlerArg *a); +RTEXITCODE handleUnregisterVM(HandlerArg *a); +RTEXITCODE handleCreateVM(HandlerArg *a); +RTEXITCODE handleCloneVM(HandlerArg *a); +RTEXITCODE handleStartVM(HandlerArg *a); +RTEXITCODE handleDiscardState(HandlerArg *a); +RTEXITCODE handleAdoptState(HandlerArg *a); +RTEXITCODE handleGetExtraData(HandlerArg *a); +RTEXITCODE handleSetExtraData(HandlerArg *a); +RTEXITCODE handleSetProperty(HandlerArg *a); +RTEXITCODE handleSharedFolder(HandlerArg *a); +RTEXITCODE handleExtPack(HandlerArg *a); +RTEXITCODE handleUnattended(HandlerArg *a); +RTEXITCODE handleMoveVM(HandlerArg *a); + +/* VBoxManageDisk.cpp */ +HRESULT openMedium(HandlerArg *a, const char *pszFilenameOrUuid, + DeviceType_T enmDevType, AccessMode_T enmAccessMode, + ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen, + bool fSilent); +RTEXITCODE handleCreateMedium(HandlerArg *a); +RTEXITCODE handleModifyMedium(HandlerArg *a); +RTEXITCODE handleCloneMedium(HandlerArg *a); +RTEXITCODE handleMediumProperty(HandlerArg *a); +RTEXITCODE handleEncryptMedium(HandlerArg *a); +RTEXITCODE handleCheckMediumPassword(HandlerArg *a); +RTEXITCODE handleConvertFromRaw(HandlerArg *a); +HRESULT showMediumInfo(const ComPtr<IVirtualBox> &pVirtualBox, + const ComPtr<IMedium> &pMedium, + const char *pszParentUUID, + bool fOptLong); +RTEXITCODE handleShowMediumInfo(HandlerArg *a); +RTEXITCODE handleCloseMedium(HandlerArg *a); +RTEXITCODE handleMediumIO(HandlerArg *a); +int parseMediumType(const char *psz, MediumType_T *penmMediumType); +int parseBool(const char *psz, bool *pb); + +/* VBoxManageStorageController.cpp */ +RTEXITCODE handleStorageAttach(HandlerArg *a); +RTEXITCODE handleStorageController(HandlerArg *a); + +// VBoxManageImport.cpp +RTEXITCODE handleImportAppliance(HandlerArg *a); +RTEXITCODE handleExportAppliance(HandlerArg *a); + +// VBoxManageSnapshot.cpp +RTEXITCODE handleSnapshot(HandlerArg *a); + +/* VBoxManageUSB.cpp */ +RTEXITCODE handleUSBFilter(HandlerArg *a); +RTEXITCODE handleUSBDevSource(HandlerArg *a); + +/* VBoxManageHostonly.cpp */ +RTEXITCODE handleHostonlyIf(HandlerArg *a); + +/* VBoxManageDHCPServer.cpp */ +RTEXITCODE handleDHCPServer(HandlerArg *a); + +/* VBoxManageNATNetwork.cpp */ +RTEXITCODE handleNATNetwork(HandlerArg *a); + + +/* VBoxManageBandwidthControl.cpp */ +RTEXITCODE handleBandwidthControl(HandlerArg *a); + +#endif /* !VBOX_ONLY_DOCS */ + +#endif /* !VBOX_INCLUDED_SRC_VBoxManage_VBoxManage_h */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManage.rc b/src/VBox/Frontends/VBoxManage/VBoxManage.rc new file mode 100644 index 00000000..eaa3b632 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManage.rc @@ -0,0 +1,51 @@ +/* $Id: VBoxManage.rc $ */ +/** @file + * VBoxManage - Resource file containing version info and icon. + */ + +/* + * Copyright (C) 2015-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include <windows.h> +#include <VBox/version.h> + +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VBOX_RC_FILE_VERSION + PRODUCTVERSION VBOX_RC_FILE_VERSION + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK + FILEFLAGS VBOX_RC_FILE_FLAGS + FILEOS VBOX_RC_FILE_OS + FILETYPE VBOX_RC_TYPE_APP + FILESUBTYPE VFT2_UNKNOWN +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" // Lang=US English, CharSet=Unicode + BEGIN + VALUE "FileDescription", "VirtualBox Command Line Tool\0" + VALUE "InternalName", "VBoxManage\0" + VALUE "OriginalFilename", "VBoxManage.exe\0" + VALUE "CompanyName", VBOX_RC_COMPANY_NAME + VALUE "FileVersion", VBOX_RC_FILE_VERSION_STR + VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT + VALUE "ProductName", VBOX_RC_PRODUCT_NAME_STR + VALUE "ProductVersion", VBOX_RC_PRODUCT_VERSION_STR + VBOX_RC_MORE_STRINGS + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp new file mode 100644 index 00000000..af80898c --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageAppliance.cpp @@ -0,0 +1,1516 @@ +/* $Id: VBoxManageAppliance.cpp $ */ +/** @file + * VBoxManage - The appliance-related commands. + */ + +/* + * Copyright (C) 2009-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <list> +#include <map> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/stream.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> +#include <iprt/path.h> +#include <iprt/file.h> + +#include <VBox/log.h> +#include <VBox/param.h> + +#include "VBoxManage.h" +using namespace com; + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + +typedef std::map<Utf8Str, Utf8Str> ArgsMap; // pairs of strings like "vmname" => "newvmname" +typedef std::map<uint32_t, ArgsMap> ArgsMapsMap; // map of maps, one for each virtual system, sorted by index + +typedef std::map<uint32_t, bool> IgnoresMap; // pairs of numeric description entry indices +typedef std::map<uint32_t, IgnoresMap> IgnoresMapsMap; // map of maps, one for each virtual system, sorted by index + +static bool findArgValue(Utf8Str &strOut, + ArgsMap *pmapArgs, + const Utf8Str &strKey) +{ + if (pmapArgs) + { + ArgsMap::iterator it; + it = pmapArgs->find(strKey); + if (it != pmapArgs->end()) + { + strOut = it->second; + pmapArgs->erase(it); + return true; + } + } + + return false; +} + +static int parseImportOptions(const char *psz, com::SafeArray<ImportOptions_T> *options) +{ + int rc = VINF_SUCCESS; + while (psz && *psz && RT_SUCCESS(rc)) + { + size_t len; + const char *pszComma = strchr(psz, ','); + if (pszComma) + len = pszComma - psz; + else + len = strlen(psz); + if (len > 0) + { + if (!RTStrNICmp(psz, "KeepAllMACs", len)) + options->push_back(ImportOptions_KeepAllMACs); + else if (!RTStrNICmp(psz, "KeepNATMACs", len)) + options->push_back(ImportOptions_KeepNATMACs); + else if (!RTStrNICmp(psz, "ImportToVDI", len)) + options->push_back(ImportOptions_ImportToVDI); + else + rc = VERR_PARSE_ERROR; + } + if (pszComma) + psz += len + 1; + else + psz += len; + } + + return rc; +} + +static const RTGETOPTDEF g_aImportApplianceOptions[] = +{ + { "--dry-run", 'n', RTGETOPT_REQ_NOTHING }, + { "-dry-run", 'n', RTGETOPT_REQ_NOTHING }, // deprecated + { "--dryrun", 'n', RTGETOPT_REQ_NOTHING }, + { "-dryrun", 'n', RTGETOPT_REQ_NOTHING }, // deprecated + { "--detailed-progress", 'P', RTGETOPT_REQ_NOTHING }, + { "-detailed-progress", 'P', RTGETOPT_REQ_NOTHING }, // deprecated + { "--vsys", 's', RTGETOPT_REQ_UINT32 }, + { "-vsys", 's', RTGETOPT_REQ_UINT32 }, // deprecated + { "--ostype", 'o', RTGETOPT_REQ_STRING }, + { "-ostype", 'o', RTGETOPT_REQ_STRING }, // deprecated + { "--vmname", 'V', RTGETOPT_REQ_STRING }, + { "-vmname", 'V', RTGETOPT_REQ_STRING }, // deprecated + { "--settingsfile", 'S', RTGETOPT_REQ_STRING }, + { "--basefolder", 'p', RTGETOPT_REQ_STRING }, + { "--group", 'g', RTGETOPT_REQ_STRING }, + { "--memory", 'm', RTGETOPT_REQ_STRING }, + { "-memory", 'm', RTGETOPT_REQ_STRING }, // deprecated + { "--cpus", 'c', RTGETOPT_REQ_STRING }, + { "--description", 'd', RTGETOPT_REQ_STRING }, + { "--eula", 'L', RTGETOPT_REQ_STRING }, + { "-eula", 'L', RTGETOPT_REQ_STRING }, // deprecated + { "--unit", 'u', RTGETOPT_REQ_UINT32 }, + { "-unit", 'u', RTGETOPT_REQ_UINT32 }, // deprecated + { "--ignore", 'x', RTGETOPT_REQ_NOTHING }, + { "-ignore", 'x', RTGETOPT_REQ_NOTHING }, // deprecated + { "--scsitype", 'T', RTGETOPT_REQ_UINT32 }, + { "-scsitype", 'T', RTGETOPT_REQ_UINT32 }, // deprecated + { "--type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated + { "-type", 'T', RTGETOPT_REQ_UINT32 }, // deprecated +#if 0 /* Changing the controller is fully valid, but the current design on how + the params are evaluated here doesn't allow two parameter for one + unit. The target disk path is more important. I leave it for future + improvments. */ + { "--controller", 'C', RTGETOPT_REQ_STRING }, +#endif + { "--disk", 'D', RTGETOPT_REQ_STRING }, + { "--options", 'O', RTGETOPT_REQ_STRING }, +}; + +RTEXITCODE handleImportAppliance(HandlerArg *arg) +{ + HRESULT rc = S_OK; + + Utf8Str strOvfFilename; + bool fExecute = true; // if true, then we actually do the import + com::SafeArray<ImportOptions_T> options; + uint32_t ulCurVsys = (uint32_t)-1; + uint32_t ulCurUnit = (uint32_t)-1; + // for each --vsys X command, maintain a map of command line items + // (we'll parse them later after interpreting the OVF, when we can + // actually check whether they make sense semantically) + ArgsMapsMap mapArgsMapsPerVsys; + IgnoresMapsMap mapIgnoresMapsPerVsys; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, arg->argc, arg->argv, g_aImportApplianceOptions, RT_ELEMENTS(g_aImportApplianceOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'n': // --dry-run + fExecute = false; + break; + + case 'P': // --detailed-progress + g_fDetailedProgress = true; + break; + + case 's': // --vsys + ulCurVsys = ValueUnion.u32; + ulCurUnit = (uint32_t)-1; + break; + + case 'o': // --ostype + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["ostype"] = ValueUnion.psz; + break; + + case 'V': // --vmname + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz; + break; + + case 'S': // --settingsfile + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["settingsfile"] = ValueUnion.psz; + break; + + case 'p': // --basefolder + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["basefolder"] = ValueUnion.psz; + break; + + case 'g': // --group + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["group"] = ValueUnion.psz; + break; + + case 'd': // --description + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz; + break; + + case 'L': // --eula + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz; + break; + + case 'm': // --memory + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["memory"] = ValueUnion.psz; + break; + + case 'c': // --cpus + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cpus"] = ValueUnion.psz; + break; + + case 'u': // --unit + ulCurUnit = ValueUnion.u32; + break; + + case 'x': // --ignore + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + if (ulCurUnit == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong); + mapIgnoresMapsPerVsys[ulCurVsys][ulCurUnit] = true; + break; + + case 'T': // --scsitype + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + if (ulCurUnit == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("scsitype%u", ulCurUnit)] = ValueUnion.psz; + break; + + case 'C': // --controller + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + if (ulCurUnit == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("controller%u", ulCurUnit)] = ValueUnion.psz; + break; + + case 'D': // --disk + if (ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + if (ulCurUnit == (uint32_t)-1) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Option \"%s\" requires preceding --unit argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys][Utf8StrFmt("disk%u", ulCurUnit)] = ValueUnion.psz; + break; + + case 'O': // --options + if (RT_FAILURE(parseImportOptions(ValueUnion.psz, &options))) + return errorArgument("Invalid import options '%s'\n", ValueUnion.psz); + break; + + case VINF_GETOPT_NOT_OPTION: + if (strOvfFilename.isEmpty()) + strOvfFilename = ValueUnion.psz; + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option -%c", c); + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, "error: %Rrs", c); + } + } + + if (strOvfFilename.isEmpty()) + return errorSyntax(USAGE_IMPORTAPPLIANCE, "Not enough arguments for \"import\" command."); + + do + { + ComPtr<IAppliance> pAppliance; + CHECK_ERROR_BREAK(arg->virtualBox, CreateAppliance(pAppliance.asOutParam())); + + char *pszAbsFilePath; + if (strOvfFilename.startsWith("S3://", RTCString::CaseInsensitive) || + strOvfFilename.startsWith("SunCloud://", RTCString::CaseInsensitive) || + strOvfFilename.startsWith("webdav://", RTCString::CaseInsensitive)) + pszAbsFilePath = RTStrDup(strOvfFilename.c_str()); + else + pszAbsFilePath = RTPathAbsDup(strOvfFilename.c_str()); + ComPtr<IProgress> progressRead; + CHECK_ERROR_BREAK(pAppliance, Read(Bstr(pszAbsFilePath).raw(), + progressRead.asOutParam())); + RTStrFree(pszAbsFilePath); + + rc = showProgress(progressRead); + CHECK_PROGRESS_ERROR_RET(progressRead, ("Appliance read failed"), RTEXITCODE_FAILURE); + + Bstr path; /* fetch the path, there is stuff like username/password removed if any */ + CHECK_ERROR_BREAK(pAppliance, COMGETTER(Path)(path.asOutParam())); + // call interpret(); this can yield both warnings and errors, so we need + // to tinker with the error info a bit + RTStrmPrintf(g_pStdErr, "Interpreting %ls...\n", path.raw()); + rc = pAppliance->Interpret(); + com::ErrorInfo info0(pAppliance, COM_IIDOF(IAppliance)); + + com::SafeArray<BSTR> aWarnings; + if (SUCCEEDED(pAppliance->GetWarnings(ComSafeArrayAsOutParam(aWarnings)))) + { + size_t cWarnings = aWarnings.size(); + for (unsigned i = 0; i < cWarnings; ++i) + { + Bstr bstrWarning(aWarnings[i]); + RTMsgWarning("%ls.", bstrWarning.raw()); + } + } + + if (FAILED(rc)) // during interpret, after printing warnings + { + com::GluePrintErrorInfo(info0); + com::GluePrintErrorContext("Interpret", __FILE__, __LINE__); + break; + } + + RTStrmPrintf(g_pStdErr, "OK.\n"); + + // fetch all disks + com::SafeArray<BSTR> retDisks; + CHECK_ERROR_BREAK(pAppliance, + COMGETTER(Disks)(ComSafeArrayAsOutParam(retDisks))); + if (retDisks.size() > 0) + { + RTPrintf("Disks:\n"); + for (unsigned i = 0; i < retDisks.size(); i++) + RTPrintf(" %ls\n", retDisks[i]); + RTPrintf("\n"); + } + + // fetch virtual system descriptions + com::SafeIfaceArray<IVirtualSystemDescription> aVirtualSystemDescriptions; + CHECK_ERROR_BREAK(pAppliance, + COMGETTER(VirtualSystemDescriptions)(ComSafeArrayAsOutParam(aVirtualSystemDescriptions))); + + size_t cVirtualSystemDescriptions = aVirtualSystemDescriptions.size(); + + // match command line arguments with virtual system descriptions; + // this is only to sort out invalid indices at this time + ArgsMapsMap::const_iterator it; + for (it = mapArgsMapsPerVsys.begin(); + it != mapArgsMapsPerVsys.end(); + ++it) + { + uint32_t ulVsys = it->first; + if (ulVsys >= cVirtualSystemDescriptions) + return errorSyntax(USAGE_IMPORTAPPLIANCE, + "Invalid index %RI32 with -vsys option; the OVF contains only %zu virtual system(s).", + ulVsys, cVirtualSystemDescriptions); + } + + uint32_t cLicensesInTheWay = 0; + + // dump virtual system descriptions and match command-line arguments + if (cVirtualSystemDescriptions > 0) + { + for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i) + { + com::SafeArray<VirtualSystemDescriptionType_T> retTypes; + com::SafeArray<BSTR> aRefs; + com::SafeArray<BSTR> aOvfValues; + com::SafeArray<BSTR> aVBoxValues; + com::SafeArray<BSTR> aExtraConfigValues; + CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i], + GetDescription(ComSafeArrayAsOutParam(retTypes), + ComSafeArrayAsOutParam(aRefs), + ComSafeArrayAsOutParam(aOvfValues), + ComSafeArrayAsOutParam(aVBoxValues), + ComSafeArrayAsOutParam(aExtraConfigValues))); + + RTPrintf("Virtual system %u:\n", i); + + // look up the corresponding command line options, if any + ArgsMap *pmapArgs = NULL; + ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i); + if (itm != mapArgsMapsPerVsys.end()) + pmapArgs = &itm->second; + + // this collects the final values for setFinalValues() + com::SafeArray<BOOL> aEnabled(retTypes.size()); + com::SafeArray<BSTR> aFinalValues(retTypes.size()); + + for (unsigned a = 0; a < retTypes.size(); ++a) + { + VirtualSystemDescriptionType_T t = retTypes[a]; + + Utf8Str strOverride; + + Bstr bstrFinalValue = aVBoxValues[a]; + + bool fIgnoreThis = mapIgnoresMapsPerVsys[i][a]; + + aEnabled[a] = true; + + switch (t) + { + case VirtualSystemDescriptionType_OS: + if (findArgValue(strOverride, pmapArgs, "ostype")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: OS type specified with --ostype: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Suggested OS type: \"%ls\"" + "\n (change with \"--vsys %u --ostype <type>\"; use \"list ostypes\" to list all possible values)\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_Name: + if (findArgValue(strOverride, pmapArgs, "vmname")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: VM name specified with --vmname: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Suggested VM name \"%ls\"" + "\n (change with \"--vsys %u --vmname <name>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_Product: + RTPrintf("%2u: Product (ignored): %ls\n", + a, aVBoxValues[a]); + break; + + case VirtualSystemDescriptionType_ProductUrl: + RTPrintf("%2u: ProductUrl (ignored): %ls\n", + a, aVBoxValues[a]); + break; + + case VirtualSystemDescriptionType_Vendor: + RTPrintf("%2u: Vendor (ignored): %ls\n", + a, aVBoxValues[a]); + break; + + case VirtualSystemDescriptionType_VendorUrl: + RTPrintf("%2u: VendorUrl (ignored): %ls\n", + a, aVBoxValues[a]); + break; + + case VirtualSystemDescriptionType_Version: + RTPrintf("%2u: Version (ignored): %ls\n", + a, aVBoxValues[a]); + break; + + case VirtualSystemDescriptionType_Description: + if (findArgValue(strOverride, pmapArgs, "description")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: Description specified with --description: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Description \"%ls\"" + "\n (change with \"--vsys %u --description <desc>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_License: + ++cLicensesInTheWay; + if (findArgValue(strOverride, pmapArgs, "eula")) + { + if (strOverride == "show") + { + RTPrintf("%2u: End-user license agreement" + "\n (accept with \"--vsys %u --eula accept\"):" + "\n\n%ls\n\n", + a, i, bstrFinalValue.raw()); + } + else if (strOverride == "accept") + { + RTPrintf("%2u: End-user license agreement (accepted)\n", + a); + --cLicensesInTheWay; + } + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, + "Argument to --eula must be either \"show\" or \"accept\"."); + } + else + RTPrintf("%2u: End-user license agreement" + "\n (display with \"--vsys %u --eula show\";" + "\n accept with \"--vsys %u --eula accept\")\n", + a, i, i); + break; + + case VirtualSystemDescriptionType_CPU: + if (findArgValue(strOverride, pmapArgs, "cpus")) + { + uint32_t cCPUs; + if ( strOverride.toInt(cCPUs) == VINF_SUCCESS + && cCPUs >= VMM_MIN_CPU_COUNT + && cCPUs <= VMM_MAX_CPU_COUNT + ) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: No. of CPUs specified with --cpus: %ls\n", + a, bstrFinalValue.raw()); + } + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, + "Argument to --cpus option must be a number greater than %d and less than %d.", + VMM_MIN_CPU_COUNT - 1, VMM_MAX_CPU_COUNT + 1); + } + else + RTPrintf("%2u: Number of CPUs: %ls\n (change with \"--vsys %u --cpus <n>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_Memory: + { + if (findArgValue(strOverride, pmapArgs, "memory")) + { + uint32_t ulMemMB; + if (VINF_SUCCESS == strOverride.toInt(ulMemMB)) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: Guest memory specified with --memory: %ls MB\n", + a, bstrFinalValue.raw()); + } + else + return errorSyntax(USAGE_IMPORTAPPLIANCE, + "Argument to --memory option must be a non-negative number."); + } + else + RTPrintf("%2u: Guest memory: %ls MB\n (change with \"--vsys %u --memory <MB>\")\n", + a, bstrFinalValue.raw(), i); + break; + } + + case VirtualSystemDescriptionType_HardDiskControllerIDE: + if (fIgnoreThis) + { + RTPrintf("%2u: IDE controller, type %ls -- disabled\n", + a, + aVBoxValues[a]); + aEnabled[a] = false; + } + else + RTPrintf("%2u: IDE controller, type %ls" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aVBoxValues[a], + i, a); + break; + + case VirtualSystemDescriptionType_HardDiskControllerSATA: + if (fIgnoreThis) + { + RTPrintf("%2u: SATA controller, type %ls -- disabled\n", + a, + aVBoxValues[a]); + aEnabled[a] = false; + } + else + RTPrintf("%2u: SATA controller, type %ls" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aVBoxValues[a], + i, a); + break; + + case VirtualSystemDescriptionType_HardDiskControllerSAS: + if (fIgnoreThis) + { + RTPrintf("%2u: SAS controller, type %ls -- disabled\n", + a, + aVBoxValues[a]); + aEnabled[a] = false; + } + else + RTPrintf("%2u: SAS controller, type %ls" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aVBoxValues[a], + i, a); + break; + + case VirtualSystemDescriptionType_HardDiskControllerSCSI: + if (fIgnoreThis) + { + RTPrintf("%2u: SCSI controller, type %ls -- disabled\n", + a, + aVBoxValues[a]); + aEnabled[a] = false; + } + else + { + Utf8StrFmt strTypeArg("scsitype%u", a); + if (findArgValue(strOverride, pmapArgs, strTypeArg)) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: SCSI controller, type set with --unit %u --scsitype: \"%ls\"\n", + a, + a, + bstrFinalValue.raw()); + } + else + RTPrintf("%2u: SCSI controller, type %ls" + "\n (change with \"--vsys %u --unit %u --scsitype {BusLogic|LsiLogic}\";" + "\n disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aVBoxValues[a], + i, a, i, a); + } + break; + + case VirtualSystemDescriptionType_HardDiskImage: + if (fIgnoreThis) + { + RTPrintf("%2u: Hard disk image: source image=%ls -- disabled\n", + a, + aOvfValues[a]); + aEnabled[a] = false; + } + else + { + Utf8StrFmt strTypeArg("disk%u", a); + RTCList<ImportOptions_T> optionsList = options.toList(); + + bstrFinalValue = aVBoxValues[a]; + + if (findArgValue(strOverride, pmapArgs, strTypeArg)) + { + if (!optionsList.contains(ImportOptions_ImportToVDI)) + { + RTUUID uuid; + /* Check if this is a uuid. If so, don't touch. */ + int vrc = RTUuidFromStr(&uuid, strOverride.c_str()); + if (vrc != VINF_SUCCESS) + { + /* Make the path absolute. */ + if (!RTPathStartsWithRoot(strOverride.c_str())) + { + char pszPwd[RTPATH_MAX]; + vrc = RTPathGetCurrent(pszPwd, RTPATH_MAX); + if (RT_SUCCESS(vrc)) + strOverride = Utf8Str(pszPwd).append(RTPATH_SLASH).append(strOverride); + } + } + bstrFinalValue = strOverride; + } + else + { + //print some error about incompatible command-line arguments + return errorSyntax(USAGE_IMPORTAPPLIANCE, + "Option --ImportToVDI shall not be used together with " + "manually set target path."); + + } + + RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n", + a, + aOvfValues[a], + bstrFinalValue.raw(), + aExtraConfigValues[a]); + } +#if 0 /* Changing the controller is fully valid, but the current design on how + the params are evaluated here doesn't allow two parameter for one + unit. The target disk path is more important I leave it for future + improvments. */ + Utf8StrFmt strTypeArg("controller%u", a); + if (findArgValue(strOverride, pmapArgs, strTypeArg)) + { + // strOverride now has the controller index as a number, but we + // need a "controller=X" format string + strOverride = Utf8StrFmt("controller=%s", strOverride.c_str()); + Bstr bstrExtraConfigValue = strOverride; + bstrExtraConfigValue.detachTo(&aExtraConfigValues[a]); + RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls\n", + a, + aOvfValues[a], + aVBoxValues[a], + aExtraConfigValues[a]); + } +#endif + else + { + strOverride = aVBoxValues[a]; + + /* + * Current solution isn't optimal. + * Better way is to provide API call for function + * Appliance::i_findMediumFormatFromDiskImage() + * and creating one new function which returns + * struct ovf::DiskImage for currently processed disk. + */ + + /* + * if user wants to convert all imported disks to VDI format + * we need to replace files extensions to "vdi" + * except CD/DVD disks + */ + if (optionsList.contains(ImportOptions_ImportToVDI)) + { + ComPtr<IVirtualBox> pVirtualBox = arg->virtualBox; + ComPtr<ISystemProperties> systemProperties; + com::SafeIfaceArray<IMediumFormat> mediumFormats; + Bstr bstrFormatName; + + CHECK_ERROR(pVirtualBox, + COMGETTER(SystemProperties)(systemProperties.asOutParam())); + + CHECK_ERROR(systemProperties, + COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats))); + + /* go through all supported media formats and store files extensions only for RAW */ + com::SafeArray<BSTR> extensions; + + for (unsigned j = 0; j < mediumFormats.size(); ++j) + { + com::SafeArray<DeviceType_T> deviceType; + ComPtr<IMediumFormat> mediumFormat = mediumFormats[j]; + CHECK_ERROR(mediumFormat, COMGETTER(Name)(bstrFormatName.asOutParam())); + Utf8Str strFormatName = Utf8Str(bstrFormatName); + + if (strFormatName.compare("RAW", Utf8Str::CaseInsensitive) == 0) + { + /* getting files extensions for "RAW" format */ + CHECK_ERROR(mediumFormat, + DescribeFileExtensions(ComSafeArrayAsOutParam(extensions), + ComSafeArrayAsOutParam(deviceType))); + break; + } + } + + /* go through files extensions for RAW format and compare them with + * extension of current file + */ + bool fReplace = true; + + const char *pszExtension = RTPathSuffix(strOverride.c_str()); + if (pszExtension) + pszExtension++; + + for (unsigned j = 0; j < extensions.size(); ++j) + { + Bstr bstrExt(extensions[j]); + Utf8Str strExtension(bstrExt); + if(strExtension.compare(pszExtension, Utf8Str::CaseInsensitive) == 0) + { + fReplace = false; + break; + } + } + + if (fReplace) + { + strOverride = strOverride.stripSuffix(); + strOverride = strOverride.append(".").append("vdi"); + } + } + + bstrFinalValue = strOverride; + + RTPrintf("%2u: Hard disk image: source image=%ls, target path=%ls, %ls" + "\n (change target path with \"--vsys %u --unit %u --disk path\";" + "\n disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aOvfValues[a], + bstrFinalValue.raw(), + aExtraConfigValues[a], + i, a, i, a); + } + } + break; + + case VirtualSystemDescriptionType_CDROM: + if (fIgnoreThis) + { + RTPrintf("%2u: CD-ROM -- disabled\n", + a); + aEnabled[a] = false; + } + else + RTPrintf("%2u: CD-ROM" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, i, a); + break; + + case VirtualSystemDescriptionType_Floppy: + if (fIgnoreThis) + { + RTPrintf("%2u: Floppy -- disabled\n", + a); + aEnabled[a] = false; + } + else + RTPrintf("%2u: Floppy" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, i, a); + break; + + case VirtualSystemDescriptionType_NetworkAdapter: + RTPrintf("%2u: Network adapter: orig %ls, config %ls, extra %ls\n", /// @todo implement once we have a plan for the back-end + a, + aOvfValues[a], + aVBoxValues[a], + aExtraConfigValues[a]); + break; + + case VirtualSystemDescriptionType_USBController: + if (fIgnoreThis) + { + RTPrintf("%2u: USB controller -- disabled\n", + a); + aEnabled[a] = false; + } + else + RTPrintf("%2u: USB controller" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, i, a); + break; + + case VirtualSystemDescriptionType_SoundCard: + if (fIgnoreThis) + { + RTPrintf("%2u: Sound card \"%ls\" -- disabled\n", + a, + aOvfValues[a]); + aEnabled[a] = false; + } + else + RTPrintf("%2u: Sound card (appliance expects \"%ls\", can change on import)" + "\n (disable with \"--vsys %u --unit %u --ignore\")\n", + a, + aOvfValues[a], + i, + a); + break; + + case VirtualSystemDescriptionType_SettingsFile: + if (findArgValue(strOverride, pmapArgs, "settingsfile")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: VM settings file name specified with --settingsfile: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Suggested VM settings file name \"%ls\"" + "\n (change with \"--vsys %u --settingsfile <filename>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_BaseFolder: + if (findArgValue(strOverride, pmapArgs, "basefolder")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: VM base folder specified with --basefolder: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Suggested VM base folder \"%ls\"" + "\n (change with \"--vsys %u --basefolder <path>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_PrimaryGroup: + if (findArgValue(strOverride, pmapArgs, "group")) + { + bstrFinalValue = strOverride; + RTPrintf("%2u: VM group specified with --group: \"%ls\"\n", + a, bstrFinalValue.raw()); + } + else + RTPrintf("%2u: Suggested VM group \"%ls\"" + "\n (change with \"--vsys %u --group <group>\")\n", + a, bstrFinalValue.raw(), i); + break; + + case VirtualSystemDescriptionType_CloudInstanceShape: + case VirtualSystemDescriptionType_CloudDomain: + case VirtualSystemDescriptionType_CloudBootDiskSize: + case VirtualSystemDescriptionType_CloudBucket: + case VirtualSystemDescriptionType_CloudOCIVCN: + case VirtualSystemDescriptionType_CloudPublicIP: + case VirtualSystemDescriptionType_CloudProfileName: + case VirtualSystemDescriptionType_CloudOCISubnet: + case VirtualSystemDescriptionType_CloudKeepObject: + case VirtualSystemDescriptionType_CloudLaunchInstance: + case VirtualSystemDescriptionType_Miscellaneous: + /** @todo VirtualSystemDescriptionType_Miscellaneous? */ + break; + + case VirtualSystemDescriptionType_Ignore: +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case VirtualSystemDescriptionType_32BitHack: +#endif + break; + } + + bstrFinalValue.detachTo(&aFinalValues[a]); + } + + if (fExecute) + CHECK_ERROR_BREAK(aVirtualSystemDescriptions[i], + SetFinalValues(ComSafeArrayAsInParam(aEnabled), + ComSafeArrayAsInParam(aFinalValues), + ComSafeArrayAsInParam(aExtraConfigValues))); + + } // for (unsigned i = 0; i < cVirtualSystemDescriptions; ++i) + + if (cLicensesInTheWay == 1) + RTMsgError("Cannot import until the license agreement listed above is accepted."); + else if (cLicensesInTheWay > 1) + RTMsgError("Cannot import until the %c license agreements listed above are accepted.", cLicensesInTheWay); + + if (!cLicensesInTheWay && fExecute) + { + // go! + ComPtr<IProgress> progress; + CHECK_ERROR_BREAK(pAppliance, + ImportMachines(ComSafeArrayAsInParam(options), progress.asOutParam())); + + rc = showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Appliance import failed"), RTEXITCODE_FAILURE); + + if (SUCCEEDED(rc)) + RTPrintf("Successfully imported the appliance.\n"); + } + } // end if (aVirtualSystemDescriptions.size() > 0) + } while (0); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static int parseExportOptions(const char *psz, com::SafeArray<ExportOptions_T> *options) +{ + int rc = VINF_SUCCESS; + while (psz && *psz && RT_SUCCESS(rc)) + { + size_t len; + const char *pszComma = strchr(psz, ','); + if (pszComma) + len = pszComma - psz; + else + len = strlen(psz); + if (len > 0) + { + if (!RTStrNICmp(psz, "CreateManifest", len)) + options->push_back(ExportOptions_CreateManifest); + else if (!RTStrNICmp(psz, "manifest", len)) + options->push_back(ExportOptions_CreateManifest); + else if (!RTStrNICmp(psz, "ExportDVDImages", len)) + options->push_back(ExportOptions_ExportDVDImages); + else if (!RTStrNICmp(psz, "iso", len)) + options->push_back(ExportOptions_ExportDVDImages); + else if (!RTStrNICmp(psz, "StripAllMACs", len)) + options->push_back(ExportOptions_StripAllMACs); + else if (!RTStrNICmp(psz, "nomacs", len)) + options->push_back(ExportOptions_StripAllMACs); + else if (!RTStrNICmp(psz, "StripAllNonNATMACs", len)) + options->push_back(ExportOptions_StripAllNonNATMACs); + else if (!RTStrNICmp(psz, "nomacsbutnat", len)) + options->push_back(ExportOptions_StripAllNonNATMACs); + else + rc = VERR_PARSE_ERROR; + } + if (pszComma) + psz += len + 1; + else + psz += len; + } + + return rc; +} + +static const RTGETOPTDEF g_aExportOptions[] = +{ + { "--output", 'o', RTGETOPT_REQ_STRING }, + { "--legacy09", 'l', RTGETOPT_REQ_NOTHING }, + { "--ovf09", 'l', RTGETOPT_REQ_NOTHING }, + { "--ovf10", '1', RTGETOPT_REQ_NOTHING }, + { "--ovf20", '2', RTGETOPT_REQ_NOTHING }, + { "--opc10", 'c', RTGETOPT_REQ_NOTHING }, + { "--manifest", 'm', RTGETOPT_REQ_NOTHING }, // obsoleted by --options + { "--iso", 'I', RTGETOPT_REQ_NOTHING }, // obsoleted by --options + { "--vsys", 's', RTGETOPT_REQ_UINT32 }, + { "--vmname", 'V', RTGETOPT_REQ_STRING }, + { "--product", 'p', RTGETOPT_REQ_STRING }, + { "--producturl", 'P', RTGETOPT_REQ_STRING }, + { "--vendor", 'n', RTGETOPT_REQ_STRING }, + { "--vendorurl", 'N', RTGETOPT_REQ_STRING }, + { "--version", 'v', RTGETOPT_REQ_STRING }, + { "--description", 'd', RTGETOPT_REQ_STRING }, + { "--eula", 'e', RTGETOPT_REQ_STRING }, + { "--eulafile", 'E', RTGETOPT_REQ_STRING }, + { "--options", 'O', RTGETOPT_REQ_STRING }, + { "--cloud", 'C', RTGETOPT_REQ_UINT32 }, + { "--cloudshape", 'S', RTGETOPT_REQ_STRING }, + { "--clouddomain", 'D', RTGETOPT_REQ_STRING }, + { "--clouddisksize", 'R', RTGETOPT_REQ_STRING }, + { "--cloudbucket", 'B', RTGETOPT_REQ_STRING }, + { "--cloudocivcn", 'Q', RTGETOPT_REQ_STRING }, + { "--cloudpublicip", 'A', RTGETOPT_REQ_STRING }, + { "--cloudprofile", 'F', RTGETOPT_REQ_STRING }, + { "--cloudocisubnet", 'T', RTGETOPT_REQ_STRING }, + { "--cloudkeepobject", 'K', RTGETOPT_REQ_STRING }, + { "--cloudlaunchinstance", 'L', RTGETOPT_REQ_STRING }, +}; + +enum +{ + NOT_SET, LOCAL, CLOUD +} exportType; + +RTEXITCODE handleExportAppliance(HandlerArg *a) +{ + HRESULT rc = S_OK; + + Utf8Str strOutputFile; + Utf8Str strOvfFormat("ovf-1.0"); // the default export version + bool fManifest = false; // the default + bool fCloud = false; // the default + exportType = NOT_SET; + bool fExportISOImages = false; // the default + com::SafeArray<ExportOptions_T> options; + std::list< ComPtr<IMachine> > llMachines; + + uint32_t ulCurVsys = (uint32_t)-1; + // for each --vsys X command, maintain a map of command line items + ArgsMapsMap mapArgsMapsPerVsys; + do + { + int c; + + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aExportOptions, + RT_ELEMENTS(g_aExportOptions), 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + Utf8Str strProductUrl; + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'o': // --output + if (strOutputFile.length()) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "You can only specify --output once."); + else + strOutputFile = ValueUnion.psz; + break; + + case 'l': // --legacy09/--ovf09 + strOvfFormat = "ovf-0.9"; + break; + + case '1': // --ovf10 + strOvfFormat = "ovf-1.0"; + break; + + case '2': // --ovf20 + strOvfFormat = "ovf-2.0"; + break; + + case 'c': // --opc + strOvfFormat = "opc-1.0"; + break; + + case 'I': // --iso + fExportISOImages = true; + break; + + case 'm': // --manifest + fManifest = true; + break; + + case 's': // --vsys + if (fCloud == false && exportType == NOT_SET) + exportType = LOCAL; + + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, + "Option \"%s\" can't be used together with \"--cloud\" argument.", + GetState.pDef->pszLong); + + ulCurVsys = ValueUnion.u32; + break; + + case 'V': // --vmname + if (exportType == NOT_SET || ulCurVsys == (uint32_t)-1) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys or --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["vmname"] = ValueUnion.psz; + break; + + case 'p': // --product + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["product"] = ValueUnion.psz; + break; + + case 'P': // --producturl + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["producturl"] = ValueUnion.psz; + break; + + case 'n': // --vendor + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["vendor"] = ValueUnion.psz; + break; + + case 'N': // --vendorurl + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["vendorurl"] = ValueUnion.psz; + break; + + case 'v': // --version + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["version"] = ValueUnion.psz; + break; + + case 'd': // --description + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["description"] = ValueUnion.psz; + break; + + case 'e': // --eula + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["eula"] = ValueUnion.psz; + break; + + case 'E': // --eulafile + if (exportType != LOCAL) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --vsys argument.", GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["eulafile"] = ValueUnion.psz; + break; + + case 'O': // --options + if (RT_FAILURE(parseExportOptions(ValueUnion.psz, &options))) + return errorArgument("Invalid export options '%s'\n", ValueUnion.psz); + break; + + /*--cloud and --vsys are orthogonal, only one must be presented*/ + case 'C': // --cloud + if (fCloud == false && exportType == NOT_SET) + { + fCloud = true; + exportType = CLOUD; + } + + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, + "Option \"%s\" can't be used together with \"--vsys\" argument.", + GetState.pDef->pszLong); + + ulCurVsys = ValueUnion.u32; + break; + + /* Cloud export settings */ + case 'S': // --cloudshape + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudshape"] = ValueUnion.psz; + break; + + case 'D': // --clouddomain + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["clouddomain"] = ValueUnion.psz; + break; + + case 'R': // --clouddisksize + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["clouddisksize"] = ValueUnion.psz; + break; + + case 'B': // --cloudbucket + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudbucket"] = ValueUnion.psz; + break; + + case 'Q': // --cloudocivcn + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudocivcn"] = ValueUnion.psz; + break; + + case 'A': // --cloudpublicip + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudpublicip"] = ValueUnion.psz; + break; + + case 'F': // --cloudprofile + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudprofile"] = ValueUnion.psz; + break; + + case 'T': // --cloudocisubnet + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudocisubnet"] = ValueUnion.psz; + break; + + case 'K': // --cloudkeepobject + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudkeepobject"] = ValueUnion.psz; + break; + + case 'L': // --cloudlaunchinstance + if (exportType != CLOUD) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Option \"%s\" requires preceding --cloud argument.", + GetState.pDef->pszLong); + mapArgsMapsPerVsys[ulCurVsys]["cloudlaunchinstance"] = ValueUnion.psz; + break; + + case VINF_GETOPT_NOT_OPTION: + { + Utf8Str strMachine(ValueUnion.psz); + // must be machine: try UUID or name + ComPtr<IMachine> machine; + CHECK_ERROR_BREAK(a->virtualBox, FindMachine(Bstr(strMachine).raw(), + machine.asOutParam())); + if (machine) + llMachines.push_back(machine); + break; + } + + default: + if (c > 0) + { + if (RT_C_IS_GRAPH(c)) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: -%c", c); + else + return errorSyntax(USAGE_EXPORTAPPLIANCE, "unhandled option: %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "unknown option: %s", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_EXPORTAPPLIANCE, "%Rrs", c); + } + + if (FAILED(rc)) + break; + } + + if (FAILED(rc)) + break; + + if (llMachines.empty()) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "At least one machine must be specified with the export command."); + if (!strOutputFile.length()) + return errorSyntax(USAGE_EXPORTAPPLIANCE, "Missing --output argument with export command."); + + // match command line arguments with the machines count + // this is only to sort out invalid indices at this time + ArgsMapsMap::const_iterator it; + for (it = mapArgsMapsPerVsys.begin(); + it != mapArgsMapsPerVsys.end(); + ++it) + { + uint32_t ulVsys = it->first; + if (ulVsys >= llMachines.size()) + return errorSyntax(USAGE_EXPORTAPPLIANCE, + "Invalid index %RI32 with -vsys option; you specified only %zu virtual system(s).", + ulVsys, llMachines.size()); + } + + ComPtr<IAppliance> pAppliance; + CHECK_ERROR_BREAK(a->virtualBox, CreateAppliance(pAppliance.asOutParam())); + + char *pszAbsFilePath = 0; + if (strOutputFile.startsWith("S3://", RTCString::CaseInsensitive) || + strOutputFile.startsWith("SunCloud://", RTCString::CaseInsensitive) || + strOutputFile.startsWith("webdav://", RTCString::CaseInsensitive) || + strOutputFile.startsWith("OCI://", RTCString::CaseInsensitive)) + pszAbsFilePath = RTStrDup(strOutputFile.c_str()); + else + pszAbsFilePath = RTPathAbsDup(strOutputFile.c_str()); + + std::list< ComPtr<IMachine> >::iterator itM; + uint32_t i=0; + for (itM = llMachines.begin(); + itM != llMachines.end(); + ++itM, ++i) + { + ComPtr<IMachine> pMachine = *itM; + ComPtr<IVirtualSystemDescription> pVSD; + CHECK_ERROR_BREAK(pMachine, ExportTo(pAppliance, Bstr(pszAbsFilePath).raw(), pVSD.asOutParam())); + + // Add additional info to the virtual system description if the user wants so + ArgsMap *pmapArgs = NULL; + ArgsMapsMap::iterator itm = mapArgsMapsPerVsys.find(i); + if (itm != mapArgsMapsPerVsys.end()) + pmapArgs = &itm->second; + if (pmapArgs) + { + ArgsMap::iterator itD; + for (itD = pmapArgs->begin(); + itD != pmapArgs->end(); + ++itD) + { + if (itD->first == "vmname") + { + //remove default value if user has specified new name (default value is set in the ExportTo()) + pVSD->RemoveDescriptionByType(VirtualSystemDescriptionType_Name); + pVSD->AddDescription(VirtualSystemDescriptionType_Name, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + } + else if (itD->first == "product") + pVSD->AddDescription(VirtualSystemDescriptionType_Product, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "producturl") + pVSD->AddDescription(VirtualSystemDescriptionType_ProductUrl, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "vendor") + pVSD->AddDescription(VirtualSystemDescriptionType_Vendor, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "vendorurl") + pVSD->AddDescription(VirtualSystemDescriptionType_VendorUrl, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "version") + pVSD->AddDescription(VirtualSystemDescriptionType_Version, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "description") + pVSD->AddDescription(VirtualSystemDescriptionType_Description, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "eula") + pVSD->AddDescription(VirtualSystemDescriptionType_License, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "eulafile") + { + Utf8Str strContent; + void *pvFile; + size_t cbFile; + int irc = RTFileReadAll(itD->second.c_str(), &pvFile, &cbFile); + if (RT_SUCCESS(irc)) + { + Bstr bstrContent((char*)pvFile, cbFile); + pVSD->AddDescription(VirtualSystemDescriptionType_License, + bstrContent.raw(), + bstrContent.raw()); + RTFileReadAllFree(pvFile, cbFile); + } + else + { + RTMsgError("Cannot read license file \"%s\" which should be included in the virtual system %u.", + itD->second.c_str(), i); + return RTEXITCODE_FAILURE; + } + } + /* add cloud export settings */ + else if (itD->first == "cloudshape") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudInstanceShape, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "clouddomain") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudDomain, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "clouddisksize") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudBootDiskSize, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudbucket") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudBucket, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudocivcn") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCIVCN, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudpublicip") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudPublicIP, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudprofile") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudProfileName, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudocisubnet") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudOCISubnet, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudkeepobject") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudKeepObject, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + else if (itD->first == "cloudlaunchinstance") + pVSD->AddDescription(VirtualSystemDescriptionType_CloudLaunchInstance, + Bstr(itD->second).raw(), + Bstr(itD->second).raw()); + } + } + } + + if (FAILED(rc)) + break; + + /* Query required passwords and supply them to the appliance. */ + com::SafeArray<BSTR> aIdentifiers; + + CHECK_ERROR_BREAK(pAppliance, GetPasswordIds(ComSafeArrayAsOutParam(aIdentifiers))); + + if (aIdentifiers.size() > 0) + { + com::SafeArray<BSTR> aPasswords(aIdentifiers.size()); + RTPrintf("Enter the passwords for the following identifiers to export the apppliance:\n"); + for (unsigned idxId = 0; idxId < aIdentifiers.size(); idxId++) + { + com::Utf8Str strPassword; + Bstr bstrPassword; + Bstr bstrId = aIdentifiers[idxId]; + + RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Password ID %s:", Utf8Str(bstrId).c_str()); + if (rcExit == RTEXITCODE_FAILURE) + { + RTStrFree(pszAbsFilePath); + return rcExit; + } + + bstrPassword = strPassword; + bstrPassword.detachTo(&aPasswords[idxId]); + } + + CHECK_ERROR_BREAK(pAppliance, AddPasswords(ComSafeArrayAsInParam(aIdentifiers), + ComSafeArrayAsInParam(aPasswords))); + } + + if (fManifest) + options.push_back(ExportOptions_CreateManifest); + + if (fExportISOImages) + options.push_back(ExportOptions_ExportDVDImages); + + ComPtr<IProgress> progress; + CHECK_ERROR_BREAK(pAppliance, Write(Bstr(strOvfFormat).raw(), + ComSafeArrayAsInParam(options), + Bstr(pszAbsFilePath).raw(), + progress.asOutParam())); + RTStrFree(pszAbsFilePath); + + rc = showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Appliance write failed"), RTEXITCODE_FAILURE); + + if (SUCCEEDED(rc)) + RTPrintf("Successfully exported %d machine(s).\n", llMachines.size()); + + } while (0); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp new file mode 100644 index 00000000..8b736c58 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageBandwidthControl.cpp @@ -0,0 +1,373 @@ +/* $Id: VBoxManageBandwidthControl.cpp $ */ +/** @file + * VBoxManage - The bandwidth control related commands. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/err.h> +#include <iprt/path.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/ctype.h> +#include <iprt/stream.h> +#include <iprt/getopt.h> +#include <VBox/log.h> + +#include "VBoxManage.h" +using namespace com; + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + + +/** + * Parses a string in the following format "n[k|m|g|K|M|G]". Stores the value + * of n expressed in bytes to *pLimit. k meas kilobit, while K means kilobyte. + * + * @returns Error message or NULL if successful. + * @param pcszLimit The string to parse. + * @param pLimit Where to store the result. + */ +static const char *parseLimit(const char *pcszLimit, int64_t *pLimit) +{ + int iMultiplier = _1M; + char *pszNext = NULL; + int rc = RTStrToInt64Ex(pcszLimit, &pszNext, 10, pLimit); + + switch (rc) + { + case VINF_SUCCESS: + break; + case VWRN_NUMBER_TOO_BIG: + return "Limit is too big\n"; + case VWRN_TRAILING_CHARS: + switch (*pszNext) + { + case 'G': iMultiplier = _1G; break; + case 'M': iMultiplier = _1M; break; + case 'K': iMultiplier = _1K; break; + case 'g': iMultiplier = 125000000; break; + case 'm': iMultiplier = 125000; break; + case 'k': iMultiplier = 125; break; + default: return "Invalid unit suffix. Valid suffixes are: k, m, g, K, M, G\n"; + } + break; + case VWRN_TRAILING_SPACES: + return "Trailing spaces in limit!\n"; + case VERR_NO_DIGITS: + return "No digits in limit specifier\n"; + default: + return "Invalid limit specifier\n"; + } + if (*pLimit < 0) + return "Limit cannot be negative\n"; + if (*pLimit > INT64_MAX / iMultiplier) + return "Limit is too big\n"; + *pLimit *= iMultiplier; + + return NULL; +} + +/** + * Handles the 'bandwidthctl myvm add' sub-command. + * @returns Exit code. + * @param a The handler argument package. + * @param bwCtrl Reference to the bandwidth control interface. + */ +static RTEXITCODE handleBandwidthControlAdd(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl) +{ + HRESULT rc = S_OK; + static const RTGETOPTDEF g_aBWCtlAddOptions[] = + { + { "--type", 't', RTGETOPT_REQ_STRING }, + { "--limit", 'l', RTGETOPT_REQ_STRING } + }; + + + Bstr name(a->argv[2]); + if (name.isEmpty()) + { + errorArgument("Bandwidth group name must not be empty!\n"); + return RTEXITCODE_FAILURE; + } + + const char *pszType = NULL; + int64_t cMaxBytesPerSec = INT64_MAX; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, g_aBWCtlAddOptions, + RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + while ( SUCCEEDED(rc) + && (c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 't': // bandwidth group type + { + if (ValueUnion.psz) + pszType = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'l': // limit + { + if (ValueUnion.psz) + { + const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec); + if (pcszError) + { + errorArgument(pcszError); + return RTEXITCODE_FAILURE; + } + } + else + rc = E_FAIL; + break; + } + + default: + { + errorGetOpt(USAGE_BANDWIDTHCONTROL, c, &ValueUnion); + rc = E_FAIL; + break; + } + } + } + + BandwidthGroupType_T enmType; + + if (!RTStrICmp(pszType, "disk")) + enmType = BandwidthGroupType_Disk; + else if (!RTStrICmp(pszType, "network")) + enmType = BandwidthGroupType_Network; + else + { + errorArgument("Invalid bandwidth group type\n"); + return RTEXITCODE_FAILURE; + } + + CHECK_ERROR2I_RET(bwCtrl, CreateBandwidthGroup(name.raw(), enmType, (LONG64)cMaxBytesPerSec), RTEXITCODE_FAILURE); + + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the 'bandwidthctl myvm set' sub-command. + * @returns Exit code. + * @param a The handler argument package. + * @param bwCtrl Reference to the bandwidth control interface. + */ +static RTEXITCODE handleBandwidthControlSet(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl) +{ + HRESULT rc = S_OK; + static const RTGETOPTDEF g_aBWCtlAddOptions[] = + { + { "--limit", 'l', RTGETOPT_REQ_STRING } + }; + + + Bstr name(a->argv[2]); + int64_t cMaxBytesPerSec = INT64_MAX; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, g_aBWCtlAddOptions, + RT_ELEMENTS(g_aBWCtlAddOptions), 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + while ( SUCCEEDED(rc) + && (c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'l': // limit + { + if (ValueUnion.psz) + { + const char *pcszError = parseLimit(ValueUnion.psz, &cMaxBytesPerSec); + if (pcszError) + { + errorArgument(pcszError); + return RTEXITCODE_FAILURE; + } + } + else + rc = E_FAIL; + break; + } + + default: + { + errorGetOpt(USAGE_BANDWIDTHCONTROL, c, &ValueUnion); + rc = E_FAIL; + break; + } + } + } + + + if (cMaxBytesPerSec != INT64_MAX) + { + ComPtr<IBandwidthGroup> bwGroup; + CHECK_ERROR2I_RET(bwCtrl, GetBandwidthGroup(name.raw(), bwGroup.asOutParam()), RTEXITCODE_FAILURE); + if (SUCCEEDED(rc)) + { + CHECK_ERROR2I_RET(bwGroup, COMSETTER(MaxBytesPerSec)((LONG64)cMaxBytesPerSec), RTEXITCODE_FAILURE); + } + } + + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the 'bandwidthctl myvm remove' sub-command. + * @returns Exit code. + * @param a The handler argument package. + * @param bwCtrl Reference to the bandwidth control interface. + */ +static RTEXITCODE handleBandwidthControlRemove(HandlerArg *a, ComPtr<IBandwidthControl> &bwCtrl) +{ + Bstr name(a->argv[2]); + CHECK_ERROR2I_RET(bwCtrl, DeleteBandwidthGroup(name.raw()), RTEXITCODE_FAILURE); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the 'bandwidthctl myvm list' sub-command. + * @returns Exit code. + * @param a The handler argument package. + * @param bwCtrl Reference to the bandwidth control interface. + */ +static RTEXITCODE handleBandwidthControlList(HandlerArg *pArgs, ComPtr<IBandwidthControl> &rptrBWControl) +{ + static const RTGETOPTDEF g_aOptions[] = + { + { "--machinereadable", 'M', RTGETOPT_REQ_NOTHING }, + }; + + VMINFO_DETAILS enmDetails = VMINFO_STANDARD; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, g_aOptions, RT_ELEMENTS(g_aOptions), 2 /*iArg*/, 0 /*fFlags*/); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'M': + enmDetails = VMINFO_MACHINEREADABLE; + break; + default: + return errorGetOpt(USAGE_BANDWIDTHCONTROL, c, &ValueUnion); + } + } + + if (FAILED(showBandwidthGroups(rptrBWControl, enmDetails))) + return RTEXITCODE_FAILURE; + + return RTEXITCODE_SUCCESS; +} + + +/** + * Handles the 'bandwidthctl' command. + * @returns Exit code. + * @param a The handler argument package. + */ +RTEXITCODE handleBandwidthControl(HandlerArg *a) +{ + HRESULT rc = S_OK; + ComPtr<IMachine> machine; + ComPtr<IBandwidthControl> bwCtrl; + + if (a->argc < 2) + return errorSyntax(USAGE_BANDWIDTHCONTROL, "Too few parameters"); + else if (a->argc > 7) + return errorSyntax(USAGE_BANDWIDTHCONTROL, "Too many parameters"); + + /* try to find the given machine */ + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam()), RTEXITCODE_FAILURE); + + /* open a session for the VM (new or shared) */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + SessionType_T st; + CHECK_ERROR_RET(a->session, COMGETTER(Type)(&st), RTEXITCODE_FAILURE); + bool fRunTime = (st == SessionType_Shared); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + rc = machine->COMGETTER(BandwidthControl)(bwCtrl.asOutParam()); + if (FAILED(rc)) goto leave; + + if (!strcmp(a->argv[1], "add")) + { + if (fRunTime) + { + errorArgument("Bandwidth groups cannot be created while the VM is running\n"); + goto leave; + } + rc = handleBandwidthControlAdd(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL; + } + else if (!strcmp(a->argv[1], "remove")) + { + if (fRunTime) + { + errorArgument("Bandwidth groups cannot be deleted while the VM is running\n"); + goto leave; + } + rc = handleBandwidthControlRemove(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL; + } + else if (!strcmp(a->argv[1], "set")) + rc = handleBandwidthControlSet(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL; + else if (!strcmp(a->argv[1], "list")) + rc = handleBandwidthControlList(a, bwCtrl) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL; + else + { + errorSyntax(USAGE_BANDWIDTHCONTROL, "Invalid parameter '%s'", Utf8Str(a->argv[1]).c_str()); + rc = E_FAIL; + } + + /* commit changes */ + if (SUCCEEDED(rc)) + CHECK_ERROR(machine, SaveSettings()); + +leave: + /* it's important to always close sessions */ + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp new file mode 100644 index 00000000..8cb0abe5 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp @@ -0,0 +1,2290 @@ +/* $Id: VBoxManageControlVM.cpp $ */ +/** @file + * VBoxManage - Implementation of the controlvm command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/ctype.h> +#include <iprt/getopt.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/uuid.h> +#include <iprt/file.h> +#include <VBox/log.h> + +#include "VBoxManage.h" + +#include <list> + + +/** + * Parses a number. + * + * @returns Valid number on success. + * @returns 0 if invalid number. All necessary bitching has been done. + * @param psz Pointer to the nic number. + */ +static unsigned parseNum(const char *psz, unsigned cMaxNum, const char *name) +{ + uint32_t u32; + char *pszNext; + int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u32); + if ( RT_SUCCESS(rc) + && *pszNext == '\0' + && u32 >= 1 + && u32 <= cMaxNum) + return (unsigned)u32; + errorArgument("Invalid %s number '%s'", name, psz); + return 0; +} + +unsigned int getMaxNics(IVirtualBox* vbox, IMachine* mach) +{ + ComPtr<ISystemProperties> info; + ChipsetType_T aChipset; + ULONG NetworkAdapterCount = 0; + HRESULT rc; + + do { + CHECK_ERROR_BREAK(vbox, COMGETTER(SystemProperties)(info.asOutParam())); + CHECK_ERROR_BREAK(mach, COMGETTER(ChipsetType)(&aChipset)); + CHECK_ERROR_BREAK(info, GetMaxNetworkAdapters(aChipset, &NetworkAdapterCount)); + + return (unsigned int)NetworkAdapterCount; + } while (0); + + return 0; +} + +#define KBDCHARDEF_MOD_NONE 0x00 +#define KBDCHARDEF_MOD_SHIFT 0x01 + +typedef struct KBDCHARDEF +{ + uint8_t u8Scancode; + uint8_t u8Modifiers; +} KBDCHARDEF; + +static const KBDCHARDEF g_aASCIIChars[0x80] = +{ + /* 0x00 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x01 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x02 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x03 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x04 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x05 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x06 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x07 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x08 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x09 ' ' */ {0x0f, KBDCHARDEF_MOD_NONE}, + /* 0x0A ' ' */ {0x1c, KBDCHARDEF_MOD_NONE}, + /* 0x0B ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x0C ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x0D ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x0E ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x0F ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x10 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x11 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x12 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x13 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x14 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x15 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x16 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x17 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x18 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x19 ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1A ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1B ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1C ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1D ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1E ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x1F ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, + /* 0x20 ' ' */ {0x39, KBDCHARDEF_MOD_NONE}, + /* 0x21 '!' */ {0x02, KBDCHARDEF_MOD_SHIFT}, + /* 0x22 '"' */ {0x28, KBDCHARDEF_MOD_SHIFT}, + /* 0x23 '#' */ {0x04, KBDCHARDEF_MOD_SHIFT}, + /* 0x24 '$' */ {0x05, KBDCHARDEF_MOD_SHIFT}, + /* 0x25 '%' */ {0x06, KBDCHARDEF_MOD_SHIFT}, + /* 0x26 '&' */ {0x08, KBDCHARDEF_MOD_SHIFT}, + /* 0x27 ''' */ {0x28, KBDCHARDEF_MOD_NONE}, + /* 0x28 '(' */ {0x0a, KBDCHARDEF_MOD_SHIFT}, + /* 0x29 ')' */ {0x0b, KBDCHARDEF_MOD_SHIFT}, + /* 0x2A '*' */ {0x09, KBDCHARDEF_MOD_SHIFT}, + /* 0x2B '+' */ {0x0d, KBDCHARDEF_MOD_SHIFT}, + /* 0x2C ',' */ {0x33, KBDCHARDEF_MOD_NONE}, + /* 0x2D '-' */ {0x0c, KBDCHARDEF_MOD_NONE}, + /* 0x2E '.' */ {0x34, KBDCHARDEF_MOD_NONE}, + /* 0x2F '/' */ {0x35, KBDCHARDEF_MOD_NONE}, + /* 0x30 '0' */ {0x0b, KBDCHARDEF_MOD_NONE}, + /* 0x31 '1' */ {0x02, KBDCHARDEF_MOD_NONE}, + /* 0x32 '2' */ {0x03, KBDCHARDEF_MOD_NONE}, + /* 0x33 '3' */ {0x04, KBDCHARDEF_MOD_NONE}, + /* 0x34 '4' */ {0x05, KBDCHARDEF_MOD_NONE}, + /* 0x35 '5' */ {0x06, KBDCHARDEF_MOD_NONE}, + /* 0x36 '6' */ {0x07, KBDCHARDEF_MOD_NONE}, + /* 0x37 '7' */ {0x08, KBDCHARDEF_MOD_NONE}, + /* 0x38 '8' */ {0x09, KBDCHARDEF_MOD_NONE}, + /* 0x39 '9' */ {0x0a, KBDCHARDEF_MOD_NONE}, + /* 0x3A ':' */ {0x27, KBDCHARDEF_MOD_SHIFT}, + /* 0x3B ';' */ {0x27, KBDCHARDEF_MOD_NONE}, + /* 0x3C '<' */ {0x33, KBDCHARDEF_MOD_SHIFT}, + /* 0x3D '=' */ {0x0d, KBDCHARDEF_MOD_NONE}, + /* 0x3E '>' */ {0x34, KBDCHARDEF_MOD_SHIFT}, + /* 0x3F '?' */ {0x35, KBDCHARDEF_MOD_SHIFT}, + /* 0x40 '@' */ {0x03, KBDCHARDEF_MOD_SHIFT}, + /* 0x41 'A' */ {0x1e, KBDCHARDEF_MOD_SHIFT}, + /* 0x42 'B' */ {0x30, KBDCHARDEF_MOD_SHIFT}, + /* 0x43 'C' */ {0x2e, KBDCHARDEF_MOD_SHIFT}, + /* 0x44 'D' */ {0x20, KBDCHARDEF_MOD_SHIFT}, + /* 0x45 'E' */ {0x12, KBDCHARDEF_MOD_SHIFT}, + /* 0x46 'F' */ {0x21, KBDCHARDEF_MOD_SHIFT}, + /* 0x47 'G' */ {0x22, KBDCHARDEF_MOD_SHIFT}, + /* 0x48 'H' */ {0x23, KBDCHARDEF_MOD_SHIFT}, + /* 0x49 'I' */ {0x17, KBDCHARDEF_MOD_SHIFT}, + /* 0x4A 'J' */ {0x24, KBDCHARDEF_MOD_SHIFT}, + /* 0x4B 'K' */ {0x25, KBDCHARDEF_MOD_SHIFT}, + /* 0x4C 'L' */ {0x26, KBDCHARDEF_MOD_SHIFT}, + /* 0x4D 'M' */ {0x32, KBDCHARDEF_MOD_SHIFT}, + /* 0x4E 'N' */ {0x31, KBDCHARDEF_MOD_SHIFT}, + /* 0x4F 'O' */ {0x18, KBDCHARDEF_MOD_SHIFT}, + /* 0x50 'P' */ {0x19, KBDCHARDEF_MOD_SHIFT}, + /* 0x51 'Q' */ {0x10, KBDCHARDEF_MOD_SHIFT}, + /* 0x52 'R' */ {0x13, KBDCHARDEF_MOD_SHIFT}, + /* 0x53 'S' */ {0x1f, KBDCHARDEF_MOD_SHIFT}, + /* 0x54 'T' */ {0x14, KBDCHARDEF_MOD_SHIFT}, + /* 0x55 'U' */ {0x16, KBDCHARDEF_MOD_SHIFT}, + /* 0x56 'V' */ {0x2f, KBDCHARDEF_MOD_SHIFT}, + /* 0x57 'W' */ {0x11, KBDCHARDEF_MOD_SHIFT}, + /* 0x58 'X' */ {0x2d, KBDCHARDEF_MOD_SHIFT}, + /* 0x59 'Y' */ {0x15, KBDCHARDEF_MOD_SHIFT}, + /* 0x5A 'Z' */ {0x2c, KBDCHARDEF_MOD_SHIFT}, + /* 0x5B '[' */ {0x1a, KBDCHARDEF_MOD_NONE}, + /* 0x5C '\' */ {0x2b, KBDCHARDEF_MOD_NONE}, + /* 0x5D ']' */ {0x1b, KBDCHARDEF_MOD_NONE}, + /* 0x5E '^' */ {0x07, KBDCHARDEF_MOD_SHIFT}, + /* 0x5F '_' */ {0x0c, KBDCHARDEF_MOD_SHIFT}, + /* 0x60 '`' */ {0x28, KBDCHARDEF_MOD_NONE}, + /* 0x61 'a' */ {0x1e, KBDCHARDEF_MOD_NONE}, + /* 0x62 'b' */ {0x30, KBDCHARDEF_MOD_NONE}, + /* 0x63 'c' */ {0x2e, KBDCHARDEF_MOD_NONE}, + /* 0x64 'd' */ {0x20, KBDCHARDEF_MOD_NONE}, + /* 0x65 'e' */ {0x12, KBDCHARDEF_MOD_NONE}, + /* 0x66 'f' */ {0x21, KBDCHARDEF_MOD_NONE}, + /* 0x67 'g' */ {0x22, KBDCHARDEF_MOD_NONE}, + /* 0x68 'h' */ {0x23, KBDCHARDEF_MOD_NONE}, + /* 0x69 'i' */ {0x17, KBDCHARDEF_MOD_NONE}, + /* 0x6A 'j' */ {0x24, KBDCHARDEF_MOD_NONE}, + /* 0x6B 'k' */ {0x25, KBDCHARDEF_MOD_NONE}, + /* 0x6C 'l' */ {0x26, KBDCHARDEF_MOD_NONE}, + /* 0x6D 'm' */ {0x32, KBDCHARDEF_MOD_NONE}, + /* 0x6E 'n' */ {0x31, KBDCHARDEF_MOD_NONE}, + /* 0x6F 'o' */ {0x18, KBDCHARDEF_MOD_NONE}, + /* 0x70 'p' */ {0x19, KBDCHARDEF_MOD_NONE}, + /* 0x71 'q' */ {0x10, KBDCHARDEF_MOD_NONE}, + /* 0x72 'r' */ {0x13, KBDCHARDEF_MOD_NONE}, + /* 0x73 's' */ {0x1f, KBDCHARDEF_MOD_NONE}, + /* 0x74 't' */ {0x14, KBDCHARDEF_MOD_NONE}, + /* 0x75 'u' */ {0x16, KBDCHARDEF_MOD_NONE}, + /* 0x76 'v' */ {0x2f, KBDCHARDEF_MOD_NONE}, + /* 0x77 'w' */ {0x11, KBDCHARDEF_MOD_NONE}, + /* 0x78 'x' */ {0x2d, KBDCHARDEF_MOD_NONE}, + /* 0x79 'y' */ {0x15, KBDCHARDEF_MOD_NONE}, + /* 0x7A 'z' */ {0x2c, KBDCHARDEF_MOD_NONE}, + /* 0x7B '{' */ {0x1a, KBDCHARDEF_MOD_SHIFT}, + /* 0x7C '|' */ {0x2b, KBDCHARDEF_MOD_SHIFT}, + /* 0x7D '}' */ {0x1b, KBDCHARDEF_MOD_SHIFT}, + /* 0x7E '~' */ {0x29, KBDCHARDEF_MOD_SHIFT}, + /* 0x7F ' ' */ {0x00, KBDCHARDEF_MOD_NONE}, +}; + +static HRESULT keyboardPutScancodes(IKeyboard *pKeyboard, const std::list<LONG> &llScancodes) +{ + /* Send scancodes to the VM. */ + com::SafeArray<LONG> saScancodes(llScancodes); + +#if 1 + HRESULT rc = S_OK; + size_t i; + for (i = 0; i < saScancodes.size(); ++i) + { + rc = pKeyboard->PutScancode(saScancodes[i]); + if (FAILED(rc)) + { + RTMsgError("Failed to send a scancode"); + break; + } + + RTThreadSleep(10); /* "Typing" too fast causes lost characters. */ + } +#else + /** @todo PutScancodes does not deliver more than 20 scancodes. */ + ULONG codesStored = 0; + HRESULT rc = pKeyboard->PutScancodes(ComSafeArrayAsInParam(saScancodes), + &codesStored); + if (SUCCEEDED(rc) && codesStored < saScancodes.size()) + { + RTMsgError("Only %d scancodes were stored", codesStored); + rc = E_FAIL; + } +#endif + + return rc; +} + +static void keyboardCharsToScancodes(const char *pch, size_t cchMax, std::list<LONG> &llScancodes, bool *pfShift) +{ + size_t cchProcessed = 0; + const char *p = pch; + while (cchProcessed < cchMax) + { + ++cchProcessed; + const uint8_t c = (uint8_t)*p++; + if (c < RT_ELEMENTS(g_aASCIIChars)) + { + const KBDCHARDEF *d = &g_aASCIIChars[c]; + if (d->u8Scancode) + { + const bool fNeedShift = RT_BOOL(d->u8Modifiers & KBDCHARDEF_MOD_SHIFT); + if (*pfShift != fNeedShift) + { + *pfShift = fNeedShift; + /* Press or release the SHIFT key. */ + llScancodes.push_back(0x2a | (fNeedShift? 0x00: 0x80)); + } + + llScancodes.push_back(d->u8Scancode); + llScancodes.push_back(d->u8Scancode | 0x80); + } + } + } +} + +static HRESULT keyboardPutString(IKeyboard *pKeyboard, int argc, char **argv) +{ + std::list<LONG> llScancodes; + bool fShift = false; + + /* Convert command line string(s) to the en-us keyboard scancodes. */ + int i; + for (i = 1 + 1; i < argc; ++i) + { + if (!llScancodes.empty()) + { + /* Insert a SPACE before the next string. */ + llScancodes.push_back(0x39); + llScancodes.push_back(0x39 | 0x80); + } + + keyboardCharsToScancodes(argv[i], strlen(argv[i]), llScancodes, &fShift); + } + + /* Release SHIFT if pressed. */ + if (fShift) + llScancodes.push_back(0x2a | 0x80); + + return keyboardPutScancodes(pKeyboard, llScancodes); +} + +static HRESULT keyboardPutFile(IKeyboard *pKeyboard, const char *pszFilename) +{ + std::list<LONG> llScancodes; + bool fShift = false; + + RTFILE File = NIL_RTFILE; + int vrc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); + if (RT_SUCCESS(vrc)) + { + uint64_t cbFile = 0; + vrc = RTFileGetSize(File, &cbFile); + if (RT_SUCCESS(vrc)) + { + const uint64_t cbFileMax = _64K; + if (cbFile <= cbFileMax) + { + const size_t cbBuffer = _4K; + char *pchBuf = (char *)RTMemAlloc(cbBuffer); + if (pchBuf) + { + size_t cbRemaining = (size_t)cbFile; + while (cbRemaining > 0) + { + const size_t cbToRead = cbRemaining > cbBuffer ? cbBuffer : cbRemaining; + + size_t cbRead = 0; + vrc = RTFileRead(File, pchBuf, cbToRead, &cbRead); + if (RT_FAILURE(vrc) || cbRead == 0) + break; + + keyboardCharsToScancodes(pchBuf, cbRead, llScancodes, &fShift); + cbRemaining -= cbRead; + } + + RTMemFree(pchBuf); + } + else + RTMsgError("Out of memory allocating %d bytes", cbBuffer); + } + else + RTMsgError("File size %RI64 is greater than %RI64: '%s'", cbFile, cbFileMax, pszFilename); + } + else + RTMsgError("Cannot get size of file '%s': %Rrc", pszFilename, vrc); + + RTFileClose(File); + } + else + RTMsgError("Cannot open file '%s': %Rrc", pszFilename, vrc); + + /* Release SHIFT if pressed. */ + if (fShift) + llScancodes.push_back(0x2a | 0x80); + + return keyboardPutScancodes(pKeyboard, llScancodes); +} + + +RTEXITCODE handleControlVM(HandlerArg *a) +{ + using namespace com; + bool fNeedsSaving = false; + HRESULT rc; + + if (a->argc < 2) + return errorSyntax(USAGE_CONTROLVM, "Not enough parameters"); + + /* try to find the given machine */ + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + /* open a session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + ComPtr<IConsole> console; + ComPtr<IMachine> sessionMachine; + + do + { + /* get the associated console */ + CHECK_ERROR_BREAK(a->session, COMGETTER(Console)(console.asOutParam())); + if (!console) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%s' is not currently running", a->argv[0]); + + /* ... and session machine */ + CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam())); + + /* which command? */ + if (!strcmp(a->argv[1], "pause")) + { + CHECK_ERROR_BREAK(console, Pause()); + } + else if (!strcmp(a->argv[1], "resume")) + { + CHECK_ERROR_BREAK(console, Resume()); + } + else if (!strcmp(a->argv[1], "reset")) + { + CHECK_ERROR_BREAK(console, Reset()); + } + else if (!strcmp(a->argv[1], "unplugcpu")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]); + rc = E_FAIL; + break; + } + + unsigned n = parseNum(a->argv[2], 32, "CPU"); + + CHECK_ERROR_BREAK(sessionMachine, HotUnplugCPU(n)); + } + else if (!strcmp(a->argv[1], "plugcpu")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected CPU number.", a->argv[1]); + rc = E_FAIL; + break; + } + + unsigned n = parseNum(a->argv[2], 32, "CPU"); + + CHECK_ERROR_BREAK(sessionMachine, HotPlugCPU(n)); + } + else if (!strcmp(a->argv[1], "cpuexecutioncap")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected execution cap number.", a->argv[1]); + rc = E_FAIL; + break; + } + + unsigned n = parseNum(a->argv[2], 100, "ExecutionCap"); + + CHECK_ERROR_BREAK(sessionMachine, COMSETTER(CPUExecutionCap)(n)); + } + else if (!strcmp(a->argv[1], "audioin")) + { + ComPtr<IAudioAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioAdapter)(adapter.asOutParam())); + if (adapter) + { + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_RET(adapter, COMSETTER(EnabledIn)(TRUE), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_RET(adapter, COMSETTER(EnabledIn)(FALSE), RTEXITCODE_FAILURE); + } + else + { + errorArgument("Invalid value '%s'", Utf8Str(a->argv[2]).c_str()); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + { + errorArgument("audio adapter not enabled in VM configuration"); + rc = E_FAIL; + break; + } + } + else if (!strcmp(a->argv[1], "audioout")) + { + ComPtr<IAudioAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioAdapter)(adapter.asOutParam())); + if (adapter) + { + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_RET(adapter, COMSETTER(EnabledOut)(TRUE), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_RET(adapter, COMSETTER(EnabledOut)(FALSE), RTEXITCODE_FAILURE); + } + else + { + errorArgument("Invalid value '%s'", Utf8Str(a->argv[2]).c_str()); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + { + errorArgument("audio adapter not enabled in VM configuration"); + rc = E_FAIL; + break; + } + } + else if (!strcmp(a->argv[1], "clipboard")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected clipboard mode.", a->argv[1]); + rc = E_FAIL; + break; + } + + ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */ + if (!strcmp(a->argv[2], "disabled")) + mode = ClipboardMode_Disabled; + else if (!strcmp(a->argv[2], "hosttoguest")) + mode = ClipboardMode_HostToGuest; + else if (!strcmp(a->argv[2], "guesttohost")) + mode = ClipboardMode_GuestToHost; + else if (!strcmp(a->argv[2], "bidirectional")) + mode = ClipboardMode_Bidirectional; + else + { + errorArgument("Invalid '%s' argument '%s'.", a->argv[1], a->argv[2]); + rc = E_FAIL; + } + if (SUCCEEDED(rc)) + { + CHECK_ERROR_BREAK(sessionMachine, COMSETTER(ClipboardMode)(mode)); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + else if (!strcmp(a->argv[1], "draganddrop")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected drag and drop mode.", a->argv[1]); + rc = E_FAIL; + break; + } + + DnDMode_T mode = DnDMode_Disabled; /* Shup up MSC. */ + if (!strcmp(a->argv[2], "disabled")) + mode = DnDMode_Disabled; + else if (!strcmp(a->argv[2], "hosttoguest")) + mode = DnDMode_HostToGuest; + else if (!strcmp(a->argv[2], "guesttohost")) + mode = DnDMode_GuestToHost; + else if (!strcmp(a->argv[2], "bidirectional")) + mode = DnDMode_Bidirectional; + else + { + errorArgument("Invalid '%s' argument '%s'.", a->argv[1], a->argv[2]); + rc = E_FAIL; + } + if (SUCCEEDED(rc)) + { + CHECK_ERROR_BREAK(sessionMachine, COMSETTER(DnDMode)(mode)); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + else if (!strcmp(a->argv[1], "poweroff")) + { + ComPtr<IProgress> progress; + CHECK_ERROR_BREAK(console, PowerDown(progress.asOutParam())); + + rc = showProgress(progress); + CHECK_PROGRESS_ERROR(progress, ("Failed to power off machine")); + } + else if (!strcmp(a->argv[1], "savestate")) + { + /* first pause so we don't trigger a live save which needs more time/resources */ + bool fPaused = false; + rc = console->Pause(); + if (FAILED(rc)) + { + bool fError = true; + if (rc == VBOX_E_INVALID_VM_STATE) + { + /* check if we are already paused */ + MachineState_T machineState; + CHECK_ERROR_BREAK(console, COMGETTER(State)(&machineState)); + /* the error code was lost by the previous instruction */ + rc = VBOX_E_INVALID_VM_STATE; + if (machineState != MachineState_Paused) + { + RTMsgError("Machine in invalid state %d -- %s\n", + machineState, machineStateToName(machineState, false)); + } + else + { + fError = false; + fPaused = true; + } + } + if (fError) + break; + } + + ComPtr<IProgress> progress; + CHECK_ERROR(sessionMachine, SaveState(progress.asOutParam())); + if (FAILED(rc)) + { + if (!fPaused) + console->Resume(); + break; + } + + rc = showProgress(progress); + CHECK_PROGRESS_ERROR(progress, ("Failed to save machine state")); + if (FAILED(rc)) + { + if (!fPaused) + console->Resume(); + } + } + else if (!strcmp(a->argv[1], "acpipowerbutton")) + { + CHECK_ERROR_BREAK(console, PowerButton()); + } + else if (!strcmp(a->argv[1], "acpisleepbutton")) + { + CHECK_ERROR_BREAK(console, SleepButton()); + } + else if (!strcmp(a->argv[1], "keyboardputscancode")) + { + ComPtr<IKeyboard> pKeyboard; + CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam())); + if (!pKeyboard) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected IBM PC AT set 2 keyboard scancode(s) as hex byte(s).", a->argv[1]); + rc = E_FAIL; + break; + } + + std::list<LONG> llScancodes; + + /* Process the command line. */ + int i; + for (i = 1 + 1; i < a->argc; i++) + { + if ( RT_C_IS_XDIGIT (a->argv[i][0]) + && RT_C_IS_XDIGIT (a->argv[i][1]) + && a->argv[i][2] == 0) + { + uint8_t u8Scancode; + int irc = RTStrToUInt8Ex(a->argv[i], NULL, 16, &u8Scancode); + if (RT_FAILURE (irc)) + { + RTMsgError("Converting '%s' returned %Rrc!", a->argv[i], rc); + rc = E_FAIL; + break; + } + + llScancodes.push_back(u8Scancode); + } + else + { + RTMsgError("Error: '%s' is not a hex byte!", a->argv[i]); + rc = E_FAIL; + break; + } + } + + if (FAILED(rc)) + break; + + rc = keyboardPutScancodes(pKeyboard, llScancodes); + } + else if (!strcmp(a->argv[1], "keyboardputstring")) + { + ComPtr<IKeyboard> pKeyboard; + CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam())); + if (!pKeyboard) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected ASCII string(s).", a->argv[1]); + rc = E_FAIL; + break; + } + + rc = keyboardPutString(pKeyboard, a->argc, a->argv); + } + else if (!strcmp(a->argv[1], "keyboardputfile")) + { + ComPtr<IKeyboard> pKeyboard; + CHECK_ERROR_BREAK(console, COMGETTER(Keyboard)(pKeyboard.asOutParam())); + if (!pKeyboard) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'. Expected file name.", a->argv[1]); + rc = E_FAIL; + break; + } + + rc = keyboardPutFile(pKeyboard, a->argv[2]); + } + else if (!strncmp(a->argv[1], "setlinkstate", 12)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_BREAK(adapter, COMSETTER(CableConnected)(TRUE)); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_BREAK(adapter, COMSETTER(CableConnected)(FALSE)); + } + else + { + errorArgument("Invalid link state '%s'", Utf8Str(a->argv[2]).c_str()); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + /* here the order in which strncmp is called is important + * cause nictracefile can be very well compared with + * nictrace and nic and thus everything will always fail + * if the order is changed + */ + else if (!strncmp(a->argv[1], "nictracefile", 12)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][12], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + BOOL fEnabled; + adapter->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + if (a->argv[2]) + { + CHECK_ERROR_RET(adapter, COMSETTER(TraceFile)(Bstr(a->argv[2]).raw()), RTEXITCODE_FAILURE); + } + else + { + errorArgument("Invalid filename or filename not specified for NIC %lu", n); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + RTMsgError("The NIC %d is currently disabled and thus its tracefile can't be changed", n); + } + } + else if (!strncmp(a->argv[1], "nictrace", 8)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][8], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + BOOL fEnabled; + adapter->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_RET(adapter, COMSETTER(TraceEnabled)(TRUE), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_RET(adapter, COMSETTER(TraceEnabled)(FALSE), RTEXITCODE_FAILURE); + } + else + { + errorArgument("Invalid nictrace%lu argument '%s'", n, Utf8Str(a->argv[2]).c_str()); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + RTMsgError("The NIC %d is currently disabled and thus its trace flag can't be changed", n); + } + } + else if( a->argc > 2 + && !strncmp(a->argv[1], "natpf", 5)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][5], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (!adapter) + { + rc = E_FAIL; + break; + } + ComPtr<INATEngine> engine; + CHECK_ERROR(adapter, COMGETTER(NATEngine)(engine.asOutParam())); + if (!engine) + { + rc = E_FAIL; + break; + } + + if (!strcmp(a->argv[2], "delete")) + { + if (a->argc >= 3) + CHECK_ERROR(engine, RemoveRedirect(Bstr(a->argv[3]).raw())); + } + else + { +#define ITERATE_TO_NEXT_TERM(ch) \ + do { \ + while (*ch != ',') \ + { \ + if (*ch == 0) \ + { \ + return errorSyntax(USAGE_CONTROLVM, \ + "Missing or invalid argument to '%s'", \ + a->argv[1]); \ + } \ + ch++; \ + } \ + *ch = '\0'; \ + ch++; \ + } while(0) + + char *strName; + char *strProto; + char *strHostIp; + char *strHostPort; + char *strGuestIp; + char *strGuestPort; + char *strRaw = RTStrDup(a->argv[2]); + char *ch = strRaw; + strName = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strProto = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strHostIp = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strHostPort = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strGuestIp = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strGuestPort = RTStrStrip(ch); + NATProtocol_T proto; + if (RTStrICmp(strProto, "udp") == 0) + proto = NATProtocol_UDP; + else if (RTStrICmp(strProto, "tcp") == 0) + proto = NATProtocol_TCP; + else + { + return errorSyntax(USAGE_CONTROLVM, + "Wrong rule proto '%s' specified -- only 'udp' and 'tcp' are allowed.", + strProto); + } + CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto, Bstr(strHostIp).raw(), + RTStrToUInt16(strHostPort), Bstr(strGuestIp).raw(), RTStrToUInt16(strGuestPort))); +#undef ITERATE_TO_NEXT_TERM + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else if (!strncmp(a->argv[1], "nicproperty", 11)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][11], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + BOOL fEnabled; + adapter->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + /* Parse 'name=value' */ + char *pszProperty = RTStrDup(a->argv[2]); + if (pszProperty) + { + char *pDelimiter = strchr(pszProperty, '='); + if (pDelimiter) + { + *pDelimiter = '\0'; + + Bstr bstrName = pszProperty; + Bstr bstrValue = &pDelimiter[1]; + CHECK_ERROR(adapter, SetProperty(bstrName.raw(), bstrValue.raw())); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + { + errorArgument("Invalid nicproperty%d argument '%s'", n, a->argv[2]); + rc = E_FAIL; + } + RTStrFree(pszProperty); + } + else + { + RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for nicproperty%d '%s'\n", n, a->argv[2]); + rc = E_FAIL; + } + if (FAILED(rc)) + break; + } + else + RTMsgError("The NIC %d is currently disabled and thus its properties can't be changed", n); + } + } + else if (!strncmp(a->argv[1], "nicpromisc", 10)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][10], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + BOOL fEnabled; + adapter->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy; + if (!strcmp(a->argv[2], "deny")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny; + else if ( !strcmp(a->argv[2], "allow-vms") + || !strcmp(a->argv[2], "allow-network")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork; + else if (!strcmp(a->argv[2], "allow-all")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll; + else + { + errorArgument("Unknown promiscuous mode policy '%s'", a->argv[2]); + rc = E_INVALIDARG; + break; + } + + CHECK_ERROR(adapter, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy)); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + RTMsgError("The NIC %d is currently disabled and thus its promiscuous mode can't be changed", n); + } + } + else if (!strncmp(a->argv[1], "nic", 3)) + { + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, sessionMachine); + unsigned n = parseNum(&a->argv[1][3], NetworkAdapterCount, "NIC"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc <= 2) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + /* get the corresponding network adapter */ + ComPtr<INetworkAdapter> adapter; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam())); + if (adapter) + { + BOOL fEnabled; + adapter->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + if (!strcmp(a->argv[2], "null")) + { + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Null), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "nat")) + { + if (a->argc == 4) + CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT), RTEXITCODE_FAILURE); + } + else if ( !strcmp(a->argv[2], "bridged") + || !strcmp(a->argv[2], "hostif")) /* backward compatibility */ + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(BridgedInterface)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "intnet")) + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(InternalNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal), RTEXITCODE_FAILURE); + } +#if defined(VBOX_WITH_NETFLT) + else if (!strcmp(a->argv[2], "hostonly")) + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(HostOnlyInterface)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly), RTEXITCODE_FAILURE); + } +#endif + else if (!strcmp(a->argv[2], "generic")) + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(GenericDriver)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "natnetwork")) + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(NATNetwork)(Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork), RTEXITCODE_FAILURE); + } + /** @todo obsolete, remove eventually */ + else if (!strcmp(a->argv[2], "vde")) + { + if (a->argc <= 3) + { + errorArgument("Missing argument to '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + CHECK_ERROR_RET(adapter, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(adapter, SetProperty(Bstr("name").raw(), Bstr(a->argv[3]).raw()), RTEXITCODE_FAILURE); + } + else + { + errorArgument("Invalid type '%s' specfied for NIC %lu", Utf8Str(a->argv[2]).c_str(), n); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + RTMsgError("The NIC %d is currently disabled and thus its attachment type can't be changed", n); + } + } + else if ( !strcmp(a->argv[1], "vrde") + || !strcmp(a->argv[1], "vrdp")) + { + if (!strcmp(a->argv[1], "vrdp")) + RTStrmPrintf(g_pStdErr, "Warning: 'vrdp' is deprecated. Use 'vrde'.\n"); + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + if (vrdeServer) + { + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(TRUE)); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(FALSE)); + } + else + { + errorArgument("Invalid remote desktop server state '%s'", Utf8Str(a->argv[2]).c_str()); + rc = E_FAIL; + break; + } + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + else if ( !strcmp(a->argv[1], "vrdeport") + || !strcmp(a->argv[1], "vrdpport")) + { + if (!strcmp(a->argv[1], "vrdpport")) + RTStrmPrintf(g_pStdErr, "Warning: 'vrdpport' is deprecated. Use 'vrdeport'.\n"); + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + if (vrdeServer) + { + Bstr ports; + + if (!strcmp(a->argv[2], "default")) + ports = "0"; + else + ports = a->argv[2]; + + CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), ports.raw())); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + else if ( !strcmp(a->argv[1], "vrdevideochannelquality") + || !strcmp(a->argv[1], "vrdpvideochannelquality")) + { + if (!strcmp(a->argv[1], "vrdpvideochannelquality")) + RTStrmPrintf(g_pStdErr, "Warning: 'vrdpvideochannelquality' is deprecated. Use 'vrdevideochannelquality'.\n"); + + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + if (vrdeServer) + { + Bstr value = a->argv[2]; + + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(), value.raw())); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + } + else if (!strcmp(a->argv[1], "vrdeproperty")) + { + if (a->argc <= 1 + 1) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + if (vrdeServer) + { + /* Parse 'name=value' */ + char *pszProperty = RTStrDup(a->argv[2]); + if (pszProperty) + { + char *pDelimiter = strchr(pszProperty, '='); + if (pDelimiter) + { + *pDelimiter = '\0'; + + Bstr bstrName = pszProperty; + Bstr bstrValue = &pDelimiter[1]; + CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw())); + if (SUCCEEDED(rc)) + fNeedsSaving = true; + } + else + { + errorArgument("Invalid vrdeproperty argument '%s'", a->argv[2]); + rc = E_FAIL; + } + RTStrFree(pszProperty); + } + else + { + RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", a->argv[2]); + rc = E_FAIL; + } + } + if (FAILED(rc)) + { + break; + } + } + else if ( !strcmp(a->argv[1], "usbattach") + || !strcmp(a->argv[1], "usbdetach")) + { + if (a->argc < 3) + { + errorSyntax(USAGE_CONTROLVM, "Not enough parameters"); + rc = E_FAIL; + break; + } + else if (a->argc == 4 || a->argc > 5) + { + errorSyntax(USAGE_CONTROLVM, "Wrong number of arguments"); + rc = E_FAIL; + break; + } + + bool attach = !strcmp(a->argv[1], "usbattach"); + + Bstr usbId = a->argv[2]; + Bstr captureFilename; + + if (a->argc == 5) + { + if (!strcmp(a->argv[3], "--capturefile")) + captureFilename = a->argv[4]; + else + { + errorArgument("Invalid parameter '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + } + + Guid guid(usbId); + if (!guid.isValid()) + { + // assume address + if (attach) + { + ComPtr<IHost> host; + CHECK_ERROR_BREAK(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + SafeIfaceArray <IHostUSBDevice> coll; + CHECK_ERROR_BREAK(host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll))); + ComPtr<IHostUSBDevice> dev; + CHECK_ERROR_BREAK(host, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(), + dev.asOutParam())); + CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam())); + } + else + { + SafeIfaceArray <IUSBDevice> coll; + CHECK_ERROR_BREAK(console, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll))); + ComPtr<IUSBDevice> dev; + CHECK_ERROR_BREAK(console, FindUSBDeviceByAddress(Bstr(a->argv[2]).raw(), + dev.asOutParam())); + CHECK_ERROR_BREAK(dev, COMGETTER(Id)(usbId.asOutParam())); + } + } + else if (guid.isZero()) + { + errorArgument("Zero UUID argument '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + + if (attach) + CHECK_ERROR_BREAK(console, AttachUSBDevice(usbId.raw(), captureFilename.raw())); + else + { + ComPtr<IUSBDevice> dev; + CHECK_ERROR_BREAK(console, DetachUSBDevice(usbId.raw(), + dev.asOutParam())); + } + } + else if (!strcmp(a->argv[1], "setvideomodehint")) + { + if (a->argc != 5 && a->argc != 6 && a->argc != 7 && a->argc != 9) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + bool fEnabled = true; + uint32_t uXRes = RTStrToUInt32(a->argv[2]); + uint32_t uYRes = RTStrToUInt32(a->argv[3]); + uint32_t uBpp = RTStrToUInt32(a->argv[4]); + uint32_t uDisplayIdx = 0; + bool fChangeOrigin = false; + int32_t iOriginX = 0; + int32_t iOriginY = 0; + if (a->argc >= 6) + uDisplayIdx = RTStrToUInt32(a->argv[5]); + if (a->argc >= 7) + { + int vrc = parseBool(a->argv[6], &fEnabled); + if (RT_FAILURE(vrc)) + { + errorSyntax(USAGE_CONTROLVM, "Either \"yes\" or \"no\" is expected"); + rc = E_FAIL; + break; + } + fEnabled = !RTStrICmp(a->argv[6], "yes"); + } + if (a->argc == 9) + { + iOriginX = RTStrToInt32(a->argv[7]); + iOriginY = RTStrToInt32(a->argv[8]); + fChangeOrigin = true; + } + + ComPtr<IDisplay> pDisplay; + CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam())); + if (!pDisplay) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + CHECK_ERROR_BREAK(pDisplay, SetVideoModeHint(uDisplayIdx, fEnabled, + fChangeOrigin, iOriginX, iOriginY, + uXRes, uYRes, uBpp)); + } + else if (!strcmp(a->argv[1], "setscreenlayout")) + { + if (a->argc < 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + ComPtr<IDisplay> pDisplay; + CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam())); + if (!pDisplay) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + + com::SafeIfaceArray<IGuestScreenInfo> aGuestScreenInfos; + + /* Parse "<display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off" sequences. */ + int argc = a->argc - 2; + char **argv = &a->argv[2]; + while (argc >= 2) + { + ULONG aDisplay = RTStrToUInt32(argv[0]); + BOOL aPrimary = FALSE; + + GuestMonitorStatus_T aStatus; + if (RTStrICmp(argv[1], "primary") == 0) + { + aStatus = GuestMonitorStatus_Enabled; + aPrimary = TRUE; + } + else if (RTStrICmp(argv[1], "on") == 0) + aStatus = GuestMonitorStatus_Enabled; + else if (RTStrICmp(argv[1], "off") == 0) + aStatus = GuestMonitorStatus_Disabled; + else + { + errorSyntax(USAGE_CONTROLVM, "Display status must be <on> or <off>"); + rc = E_FAIL; + break; + } + + BOOL aChangeOrigin = FALSE; + LONG aOriginX = 0; + LONG aOriginY = 0; + ULONG aWidth = 0; + ULONG aHeight = 0; + ULONG aBitsPerPixel = 0; + if (aStatus == GuestMonitorStatus_Enabled) + { + if (argc < 7) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + aChangeOrigin = TRUE; + aOriginX = RTStrToUInt32(argv[2]); + aOriginY = RTStrToUInt32(argv[3]); + aWidth = RTStrToUInt32(argv[4]); + aHeight = RTStrToUInt32(argv[5]); + aBitsPerPixel = RTStrToUInt32(argv[6]); + + argc -= 7; + argv += 7; + } + else + { + argc -= 2; + argv += 2; + } + + ComPtr<IGuestScreenInfo> pInfo; + CHECK_ERROR_BREAK(pDisplay, CreateGuestScreenInfo(aDisplay, aStatus, aPrimary, aChangeOrigin, + aOriginX, aOriginY, aWidth, aHeight, aBitsPerPixel, + pInfo.asOutParam())); + aGuestScreenInfos.push_back(pInfo); + } + + if (FAILED(rc)) + break; + + CHECK_ERROR_BREAK(pDisplay, SetScreenLayout(ScreenLayoutMode_Apply, ComSafeArrayAsInParam(aGuestScreenInfos))); + } + else if (!strcmp(a->argv[1], "setcredentials")) + { + bool fAllowLocalLogon = true; + if ( a->argc == 7 + || ( a->argc == 8 + && ( !strcmp(a->argv[3], "-p") + || !strcmp(a->argv[3], "--passwordfile")))) + { + if ( strcmp(a->argv[5 + (a->argc - 7)], "--allowlocallogon") + && strcmp(a->argv[5 + (a->argc - 7)], "-allowlocallogon")) + { + errorArgument("Invalid parameter '%s'", a->argv[5]); + rc = E_FAIL; + break; + } + if (!strcmp(a->argv[6 + (a->argc - 7)], "no")) + fAllowLocalLogon = false; + } + else if ( a->argc != 5 + && ( a->argc != 6 + || ( strcmp(a->argv[3], "-p") + && strcmp(a->argv[3], "--passwordfile")))) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + Utf8Str passwd, domain; + if (a->argc == 5 || a->argc == 7) + { + passwd = a->argv[3]; + domain = a->argv[4]; + } + else + { + RTEXITCODE rcExit = readPasswordFile(a->argv[4], &passwd); + if (rcExit != RTEXITCODE_SUCCESS) + { + rc = E_FAIL; + break; + } + domain = a->argv[5]; + } + + ComPtr<IGuest> pGuest; + CHECK_ERROR_BREAK(console, COMGETTER(Guest)(pGuest.asOutParam())); + if (!pGuest) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + CHECK_ERROR_BREAK(pGuest, SetCredentials(Bstr(a->argv[2]).raw(), + Bstr(passwd).raw(), + Bstr(domain).raw(), + fAllowLocalLogon)); + } +#if 0 /** @todo review & remove */ + else if (!strcmp(a->argv[1], "dvdattach")) + { + Bstr uuid; + if (a->argc != 3) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + ComPtr<IMedium> dvdMedium; + + /* unmount? */ + if (!strcmp(a->argv[2], "none")) + { + /* nothing to do, NULL object will cause unmount */ + } + /* host drive? */ + else if (!strncmp(a->argv[2], "host:", 5)) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + + rc = host->FindHostDVDDrive(Bstr(a->argv[2] + 5), dvdMedium.asOutParam()); + if (!dvdMedium) + { + errorArgument("Invalid host DVD drive name \"%s\"", + a->argv[2] + 5); + rc = E_FAIL; + break; + } + } + else + { + /* first assume it's a UUID */ + uuid = a->argv[2]; + rc = a->virtualBox->GetDVDImage(uuid, dvdMedium.asOutParam()); + if (FAILED(rc) || !dvdMedium) + { + /* must be a filename, check if it's in the collection */ + rc = a->virtualBox->FindDVDImage(Bstr(a->argv[2]), dvdMedium.asOutParam()); + /* not registered, do that on the fly */ + if (!dvdMedium) + { + Bstr emptyUUID; + CHECK_ERROR(a->virtualBox, OpenDVDImage(Bstr(a->argv[2]), emptyUUID, dvdMedium.asOutParam())); + } + } + if (!dvdMedium) + { + rc = E_FAIL; + break; + } + } + + /** @todo generalize this, allow arbitrary number of DVD drives + * and as a consequence multiple attachments and different + * storage controllers. */ + if (dvdMedium) + dvdMedium->COMGETTER(Id)(uuid.asOutParam()); + else + uuid = Guid().toString(); + CHECK_ERROR(machine, MountMedium(Bstr("IDE Controller"), 1, 0, uuid, FALSE /* aForce */)); + } + else if (!strcmp(a->argv[1], "floppyattach")) + { + Bstr uuid; + if (a->argc != 3) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + ComPtr<IMedium> floppyMedium; + + /* unmount? */ + if (!strcmp(a->argv[2], "none")) + { + /* nothing to do, NULL object will cause unmount */ + } + /* host drive? */ + else if (!strncmp(a->argv[2], "host:", 5)) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + host->FindHostFloppyDrive(Bstr(a->argv[2] + 5), floppyMedium.asOutParam()); + if (!floppyMedium) + { + errorArgument("Invalid host floppy drive name \"%s\"", + a->argv[2] + 5); + rc = E_FAIL; + break; + } + } + else + { + /* first assume it's a UUID */ + uuid = a->argv[2]; + rc = a->virtualBox->GetFloppyImage(uuid, floppyMedium.asOutParam()); + if (FAILED(rc) || !floppyMedium) + { + /* must be a filename, check if it's in the collection */ + rc = a->virtualBox->FindFloppyImage(Bstr(a->argv[2]), floppyMedium.asOutParam()); + /* not registered, do that on the fly */ + if (!floppyMedium) + { + Bstr emptyUUID; + CHECK_ERROR(a->virtualBox, OpenFloppyImage(Bstr(a->argv[2]), emptyUUID, floppyMedium.asOutParam())); + } + } + if (!floppyMedium) + { + rc = E_FAIL; + break; + } + } + floppyMedium->COMGETTER(Id)(uuid.asOutParam()); + CHECK_ERROR(machine, MountMedium(Bstr("Floppy Controller"), 0, 0, uuid, FALSE /* aForce */)); + } +#endif /* obsolete dvdattach/floppyattach */ + else if (!strcmp(a->argv[1], "guestmemoryballoon")) + { + if (a->argc != 3) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + uint32_t uVal; + int vrc; + vrc = RTStrToUInt32Ex(a->argv[2], NULL, 0, &uVal); + if (vrc != VINF_SUCCESS) + { + errorArgument("Error parsing guest memory balloon size '%s'", a->argv[2]); + rc = E_FAIL; + break; + } + /* guest is running; update IGuest */ + ComPtr<IGuest> pGuest; + rc = console->COMGETTER(Guest)(pGuest.asOutParam()); + if (SUCCEEDED(rc)) + { + if (!pGuest) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + CHECK_ERROR(pGuest, COMSETTER(MemoryBalloonSize)(uVal)); + } + } + else if (!strcmp(a->argv[1], "teleport")) + { + Bstr bstrHostname; + uint32_t uMaxDowntime = 250 /*ms*/; + uint32_t uPort = UINT32_MAX; + uint32_t cMsTimeout = 0; + Utf8Str strPassword; + static const RTGETOPTDEF s_aTeleportOptions[] = + { + { "--host", 'h', RTGETOPT_REQ_STRING }, /** @todo RTGETOPT_FLAG_MANDATORY */ + { "--hostname", 'h', RTGETOPT_REQ_STRING }, /** @todo remove this */ + { "--maxdowntime", 'd', RTGETOPT_REQ_UINT32 }, + { "--port", 'P', RTGETOPT_REQ_UINT32 }, /** @todo RTGETOPT_FLAG_MANDATORY */ + { "--passwordfile", 'p', RTGETOPT_REQ_STRING }, + { "--password", 'W', RTGETOPT_REQ_STRING }, + { "--timeout", 't', RTGETOPT_REQ_UINT32 }, + { "--detailed-progress", 'D', RTGETOPT_REQ_NOTHING } + }; + RTGETOPTSTATE GetOptState; + RTGetOptInit(&GetOptState, a->argc, a->argv, s_aTeleportOptions, RT_ELEMENTS(s_aTeleportOptions), 2, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + int ch; + RTGETOPTUNION Value; + while ( SUCCEEDED(rc) + && (ch = RTGetOpt(&GetOptState, &Value))) + { + switch (ch) + { + case 'h': bstrHostname = Value.psz; break; + case 'd': uMaxDowntime = Value.u32; break; + case 'D': g_fDetailedProgress = true; break; + case 'P': uPort = Value.u32; break; + case 'p': + { + RTEXITCODE rcExit = readPasswordFile(Value.psz, &strPassword); + if (rcExit != RTEXITCODE_SUCCESS) + rc = E_FAIL; + break; + } + case 'W': strPassword = Value.psz; break; + case 't': cMsTimeout = Value.u32; break; + default: + errorGetOpt(USAGE_CONTROLVM, ch, &Value); + rc = E_FAIL; + break; + } + } + if (FAILED(rc)) + break; + + ComPtr<IProgress> progress; + CHECK_ERROR_BREAK(console, Teleport(bstrHostname.raw(), uPort, + Bstr(strPassword).raw(), + uMaxDowntime, + progress.asOutParam())); + + if (cMsTimeout) + { + rc = progress->COMSETTER(Timeout)(cMsTimeout); + if (FAILED(rc) && rc != VBOX_E_INVALID_OBJECT_STATE) + CHECK_ERROR_BREAK(progress, COMSETTER(Timeout)(cMsTimeout)); /* lazyness */ + } + + rc = showProgress(progress); + CHECK_PROGRESS_ERROR(progress, ("Teleportation failed")); + } + else if (!strcmp(a->argv[1], "screenshotpng")) + { + if (a->argc <= 2 || a->argc > 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + int vrc; + uint32_t iScreen = 0; + if (a->argc == 4) + { + vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &iScreen); + if (vrc != VINF_SUCCESS) + { + errorArgument("Error parsing display number '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + } + ComPtr<IDisplay> pDisplay; + CHECK_ERROR_BREAK(console, COMGETTER(Display)(pDisplay.asOutParam())); + if (!pDisplay) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + ULONG width, height, bpp; + LONG xOrigin, yOrigin; + GuestMonitorStatus_T monitorStatus; + CHECK_ERROR_BREAK(pDisplay, GetScreenResolution(iScreen, &width, &height, &bpp, &xOrigin, &yOrigin, &monitorStatus)); + com::SafeArray<BYTE> saScreenshot; + CHECK_ERROR_BREAK(pDisplay, TakeScreenShotToArray(iScreen, width, height, BitmapFormat_PNG, ComSafeArrayAsOutParam(saScreenshot))); + RTFILE pngFile = NIL_RTFILE; + vrc = RTFileOpen(&pngFile, a->argv[2], RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_TRUNCATE | RTFILE_O_DENY_ALL); + if (RT_FAILURE(vrc)) + { + RTMsgError("Failed to create file '%s' (%Rrc)", a->argv[2], vrc); + rc = E_FAIL; + break; + } + vrc = RTFileWrite(pngFile, saScreenshot.raw(), saScreenshot.size(), NULL); + if (RT_FAILURE(vrc)) + { + RTMsgError("Failed to write screenshot to file '%s' (%Rrc)", a->argv[2], vrc); + rc = E_FAIL; + } + RTFileClose(pngFile); + } +#ifdef VBOX_WITH_RECORDING + else if (!strcmp(a->argv[1], "recording")) + { + if (a->argc < 3) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + ComPtr<IRecordingSettings> recordingSettings; + CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam())); + + SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens; + CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens))); + + /* Note: For now all screens have the same configuration. */ + + /* + * Note: Commands starting with "vcp" are the deprecated versions and are + * kept to ensure backwards compatibility. + */ + if (!strcmp(a->argv[2], "on")) + { + CHECK_ERROR_RET(recordingSettings, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "off")) + { + CHECK_ERROR_RET(recordingSettings, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[2], "screens")) + { + ULONG cMonitors = 64; + CHECK_ERROR_BREAK(machine, COMGETTER(MonitorCount)(&cMonitors)); + com::SafeArray<BOOL> saScreens(cMonitors); + if ( a->argc == 4 + && !strcmp(a->argv[3], "all")) + { + /* enable all screens */ + for (unsigned i = 0; i < cMonitors; i++) + saScreens[i] = true; + } + else if ( a->argc == 4 + && !strcmp(a->argv[3], "none")) + { + /* disable all screens */ + for (unsigned i = 0; i < cMonitors; i++) + saScreens[i] = false; + + /** @todo r=andy What if this is specified? */ + } + else + { + /* enable selected screens */ + for (unsigned i = 0; i < cMonitors; i++) + saScreens[i] = false; + for (int i = 3; SUCCEEDED(rc) && i < a->argc; i++) + { + uint32_t iScreen; + int vrc = RTStrToUInt32Ex(a->argv[i], NULL, 0, &iScreen); + if (vrc != VINF_SUCCESS) + { + errorArgument("Error parsing display number '%s'", a->argv[i]); + rc = E_FAIL; + break; + } + if (iScreen >= cMonitors) + { + errorArgument("Invalid screen ID specified '%u'", iScreen); + rc = E_FAIL; + break; + } + saScreens[iScreen] = true; + } + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(saScreens[i])); + } + else if (!strcmp(a->argv[2], "filename")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Filename)(Bstr(a->argv[3]).raw())); + } + else if ( !strcmp(a->argv[2], "videores") + || !strcmp(a->argv[2], "videoresolution")) + { + if (a->argc != 5) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + uint32_t uWidth; + int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uWidth); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing video width '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + + uint32_t uHeight; + vrc = RTStrToUInt32Ex(a->argv[4], NULL, 0, &uHeight); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing video height '%s'", a->argv[4]); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + { + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth)); + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight)); + } + } + else if (!strcmp(a->argv[2], "videorate")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + uint32_t uRate; + int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uRate); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing video rate '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoRate)(uRate)); + } + else if (!strcmp(a->argv[2], "videofps")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + uint32_t uFPS; + int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uFPS); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing video FPS '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(uFPS)); + } + else if (!strcmp(a->argv[2], "maxtime")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + uint32_t uMaxTime; + int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uMaxTime); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing maximum time '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxTime)(uMaxTime)); + } + else if (!strcmp(a->argv[2], "maxfilesize")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + uint32_t uMaxFileSize; + int vrc = RTStrToUInt32Ex(a->argv[3], NULL, 0, &uMaxFileSize); + if (RT_FAILURE(vrc)) + { + errorArgument("Error parsing maximum file size '%s'", a->argv[3]); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(uMaxFileSize)); + } + else if (!strcmp(a->argv[2], "opts")) + { + if (a->argc != 4) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Options)(Bstr(a->argv[3]).raw())); + } + } +#endif /* VBOX_WITH_RECORDING */ + else if (!strcmp(a->argv[1], "webcam")) + { + if (a->argc < 3) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + ComPtr<IEmulatedUSB> pEmulatedUSB; + CHECK_ERROR_BREAK(console, COMGETTER(EmulatedUSB)(pEmulatedUSB.asOutParam())); + if (!pEmulatedUSB) + { + RTMsgError("Guest not running"); + rc = E_FAIL; + break; + } + + if (!strcmp(a->argv[2], "attach")) + { + Bstr path(""); + if (a->argc >= 4) + path = a->argv[3]; + Bstr settings(""); + if (a->argc >= 5) + settings = a->argv[4]; + CHECK_ERROR_BREAK(pEmulatedUSB, WebcamAttach(path.raw(), settings.raw())); + } + else if (!strcmp(a->argv[2], "detach")) + { + Bstr path(""); + if (a->argc >= 4) + path = a->argv[3]; + CHECK_ERROR_BREAK(pEmulatedUSB, WebcamDetach(path.raw())); + } + else if (!strcmp(a->argv[2], "list")) + { + com::SafeArray <BSTR> webcams; + CHECK_ERROR_BREAK(pEmulatedUSB, COMGETTER(Webcams)(ComSafeArrayAsOutParam(webcams))); + for (size_t i = 0; i < webcams.size(); ++i) + { + RTPrintf("%ls\n", webcams[i][0]? webcams[i]: Bstr("default").raw()); + } + } + else + { + errorArgument("Invalid argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + } + else if (!strcmp(a->argv[1], "addencpassword")) + { + if ( a->argc != 4 + && a->argc != 6) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + break; + } + + BOOL fRemoveOnSuspend = FALSE; + if (a->argc == 6) + { + if ( strcmp(a->argv[4], "--removeonsuspend") + || ( strcmp(a->argv[5], "yes") + && strcmp(a->argv[5], "no"))) + { + errorSyntax(USAGE_CONTROLVM, "Invalid parameters"); + break; + } + if (!strcmp(a->argv[5], "yes")) + fRemoveOnSuspend = TRUE; + } + + Bstr bstrPwId(a->argv[2]); + Utf8Str strPassword; + + if (!RTStrCmp(a->argv[3], "-")) + { + /* Get password from console. */ + RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:"); + if (rcExit == RTEXITCODE_FAILURE) + break; + } + else + { + RTEXITCODE rcExit = readPasswordFile(a->argv[3], &strPassword); + if (rcExit == RTEXITCODE_FAILURE) + { + RTMsgError("Failed to read new password from file"); + break; + } + } + + CHECK_ERROR_BREAK(console, AddDiskEncryptionPassword(bstrPwId.raw(), Bstr(strPassword).raw(), fRemoveOnSuspend)); + } + else if (!strcmp(a->argv[1], "removeencpassword")) + { + if (a->argc != 3) + { + errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters"); + break; + } + Bstr bstrPwId(a->argv[2]); + CHECK_ERROR_BREAK(console, RemoveDiskEncryptionPassword(bstrPwId.raw())); + } + else if (!strcmp(a->argv[1], "removeallencpasswords")) + { + CHECK_ERROR_BREAK(console, ClearAllDiskEncryptionPasswords()); + } + else if (!strncmp(a->argv[1], "changeuartmode", 14)) + { + unsigned n = parseNum(&a->argv[1][14], 4, "UART"); + if (!n) + { + rc = E_FAIL; + break; + } + if (a->argc < 3) + { + errorArgument("Missing argument to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + ComPtr<ISerialPort> uart; + + CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(n - 1, uart.asOutParam())); + ASSERT(uart); + + if (!RTStrICmp(a->argv[2], "disconnected")) + { + if (a->argc != 3) + { + errorArgument("Incorrect arguments to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected)); + } + else if ( !RTStrICmp(a->argv[2], "server") + || !RTStrICmp(a->argv[2], "client") + || !RTStrICmp(a->argv[2], "tcpserver") + || !RTStrICmp(a->argv[2], "tcpclient") + || !RTStrICmp(a->argv[2], "file")) + { + const char *pszMode = a->argv[2]; + if (a->argc != 4) + { + errorArgument("Incorrect arguments to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + + CHECK_ERROR(uart, COMSETTER(Path)(Bstr(a->argv[3]).raw())); + + /* + * Change to disconnected first to get changes in just a parameter causing + * the correct changes later on. + */ + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected)); + if (!RTStrICmp(pszMode, "server")) + { + CHECK_ERROR(uart, COMSETTER(Server)(TRUE)); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe)); + } + else if (!RTStrICmp(pszMode, "client")) + { + CHECK_ERROR(uart, COMSETTER(Server)(FALSE)); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe)); + } + else if (!RTStrICmp(pszMode, "tcpserver")) + { + CHECK_ERROR(uart, COMSETTER(Server)(TRUE)); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP)); + } + else if (!RTStrICmp(pszMode, "tcpclient")) + { + CHECK_ERROR(uart, COMSETTER(Server)(FALSE)); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP)); + } + else if (!RTStrICmp(pszMode, "file")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile)); + } + } + else + { + if (a->argc != 3) + { + errorArgument("Incorrect arguments to '%s'", a->argv[1]); + rc = E_FAIL; + break; + } + CHECK_ERROR(uart, COMSETTER(Path)(Bstr(a->argv[2]).raw())); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice)); + } + } + else + { + errorSyntax(USAGE_CONTROLVM, "Invalid parameter '%s'", a->argv[1]); + rc = E_FAIL; + } + } while (0); + + /* The client has to trigger saving the state explicitely. */ + if (fNeedsSaving) + CHECK_ERROR(sessionMachine, SaveSettings()); + + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp new file mode 100644 index 00000000..499c60a3 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageDHCPServer.cpp @@ -0,0 +1,525 @@ +/* $Id: VBoxManageDHCPServer.cpp $ */ +/** @file + * VBoxManage - Implementation of dhcpserver command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/cidr.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/net.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> + +#include <VBox/log.h> + +#include "VBoxManage.h" + +#include <string> +#include <vector> +#include <map> + +#ifndef VBOX_ONLY_DOCS +using namespace com; + +typedef enum enMainOpCodes +{ + OP_ADD = 1000, + OP_REMOVE, + OP_MODIFY, + OP_RESTART +} OPCODE; + +typedef std::pair<DhcpOpt_T, std::string> DhcpOptSpec; +typedef std::vector<DhcpOptSpec> DhcpOpts; +typedef DhcpOpts::iterator DhcpOptIterator; + +typedef std::vector<DhcpOpt_T> DhcpOptIds; +typedef DhcpOptIds::iterator DhcpOptIdIterator; + +struct VmNameSlotKey +{ + const std::string VmName; + uint8_t u8Slot; + + VmNameSlotKey(const std::string &aVmName, uint8_t aSlot) + : VmName(aVmName) + , u8Slot(aSlot) + {} + + bool operator< (const VmNameSlotKey& that) const + { + if (VmName == that.VmName) + return u8Slot < that.u8Slot; + else + return VmName < that.VmName; + } +}; + +typedef std::map<VmNameSlotKey, DhcpOpts> VmSlot2OptionsM; +typedef VmSlot2OptionsM::iterator VmSlot2OptionsIterator; +typedef VmSlot2OptionsM::value_type VmSlot2OptionsPair; + +typedef std::map<VmNameSlotKey, DhcpOptIds> VmSlot2OptionIdsM; +typedef VmSlot2OptionIdsM::iterator VmSlot2OptionIdsIterator; + +typedef std::vector<VmNameSlotKey> VmConfigs; + +static const RTGETOPTDEF g_aDHCPIPOptions[] = +{ + { "--netname", 't', RTGETOPT_REQ_STRING }, /* we use 't' instead of 'n' to avoid + * 1. the misspelled "-enable" long option to be treated as 'e' (for -enable) + 'n' (for -netname) + "<the_rest_opt>" (for net name) + * 2. the misspelled "-netmask" to be treated as 'n' (for -netname) + "<the_rest_opt>" (for net name) + */ + { "-netname", 't', RTGETOPT_REQ_STRING }, // deprecated (if removed check below) + { "--ifname", 'f', RTGETOPT_REQ_STRING }, /* we use 'f' instead of 'i' to avoid + * 1. the misspelled "-disable" long option to be treated as 'd' (for -disable) + 'i' (for -ifname) + "<the_rest_opt>" (for if name) + */ + { "-ifname", 'f', RTGETOPT_REQ_STRING }, // deprecated + { "--ip", 'a', RTGETOPT_REQ_STRING }, + { "-ip", 'a', RTGETOPT_REQ_STRING }, // deprecated + { "--netmask", 'm', RTGETOPT_REQ_STRING }, + { "-netmask", 'm', RTGETOPT_REQ_STRING }, // deprecated + { "--lowerip", 'l', RTGETOPT_REQ_STRING }, + { "-lowerip", 'l', RTGETOPT_REQ_STRING }, // deprecated + { "--upperip", 'u', RTGETOPT_REQ_STRING }, + { "-upperip", 'u', RTGETOPT_REQ_STRING }, // deprecated + { "--enable", 'e', RTGETOPT_REQ_NOTHING }, + { "-enable", 'e', RTGETOPT_REQ_NOTHING }, // deprecated + { "--disable", 'd', RTGETOPT_REQ_NOTHING }, + { "-disable", 'd', RTGETOPT_REQ_NOTHING }, // deprecated + { "--options", 'o', RTGETOPT_REQ_NOTHING }, + { "--vm", 'M', RTGETOPT_REQ_STRING}, /* only with -o */ + { "--nic", 'n', RTGETOPT_REQ_UINT8}, /* only with -o and -M */ + { "--id", 'i', RTGETOPT_REQ_UINT8}, /* only with -o */ + { "--value", 'p', RTGETOPT_REQ_STRING}, /* only with -i */ + { "--remove", 'r', RTGETOPT_REQ_NOTHING} /* only with -i */ +}; + +static RTEXITCODE handleOp(HandlerArg *a, OPCODE enmCode, int iStart) +{ + if (a->argc - iStart < 2) + return errorSyntax(USAGE_DHCPSERVER, "Not enough parameters"); + + int index = iStart; + HRESULT rc; + bool fOptionsRead = false; + bool fVmOptionRead = false; + + const char *pszVmName = NULL; + const char *pNetName = NULL; + const char *pIfName = NULL; + const char * pIp = NULL; + const char * pNetmask = NULL; + const char * pLowerIp = NULL; + const char * pUpperIp = NULL; + + uint8_t u8OptId = (uint8_t)~0; + uint8_t u8Slot = (uint8_t)~0; + + int enable = -1; + + DhcpOpts GlobalDhcpOptions; + DhcpOptIds GlobalDhcpOptions2Delete; + VmSlot2OptionsM VmSlot2Options; + VmSlot2OptionIdsM VmSlot2Options2Delete; + VmConfigs VmConfigs2Delete; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, + a->argc, + a->argv, + g_aDHCPIPOptions, + enmCode != OP_REMOVE ? RT_ELEMENTS(g_aDHCPIPOptions) : 4, /* we use only --netname and --ifname for remove*/ + index, + RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 't': // --netname + if(pNetName) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --netname once."); + else if (pIfName) + return errorSyntax(USAGE_DHCPSERVER, "You can either use a --netname or --ifname for identifying the DHCP server."); + else + { + pNetName = ValueUnion.psz; + } + break; + case 'f': // --ifname + if(pIfName) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --ifname once."); + else if (pNetName) + return errorSyntax(USAGE_DHCPSERVER, "You can either use a --netname or --ipname for identifying the DHCP server."); + else + { + pIfName = ValueUnion.psz; + } + break; + case 'a': // -ip + if(pIp) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --ip once."); + else + { + pIp = ValueUnion.psz; + } + break; + case 'm': // --netmask + if(pNetmask) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --netmask once."); + else + { + pNetmask = ValueUnion.psz; + } + break; + case 'l': // --lowerip + if(pLowerIp) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --lowerip once."); + else + { + pLowerIp = ValueUnion.psz; + } + break; + case 'u': // --upperip + if(pUpperIp) + return errorSyntax(USAGE_DHCPSERVER, "You can only specify --upperip once."); + else + { + pUpperIp = ValueUnion.psz; + } + break; + case 'e': // --enable + if(enable >= 0) + return errorSyntax(USAGE_DHCPSERVER, "You can specify either --enable or --disable once."); + else + { + enable = 1; + } + break; + case 'd': // --disable + if(enable >= 0) + return errorSyntax(USAGE_DHCPSERVER, "You can specify either --enable or --disable once."); + else + { + enable = 0; + } + break; + case VINF_GETOPT_NOT_OPTION: + return errorSyntax(USAGE_DHCPSERVER, "unhandled parameter: %s", ValueUnion.psz); + break; + + case 'o': // --options + { + // {"--vm", 'n', RTGETOPT_REQ_STRING}, /* only with -o */ + // {"--nic", 'c', RTGETOPT_REQ_UINT8}, /* only with -o and -n*/ + // {"--id", 'i', RTGETOPT_REQ_UINT8}, /* only with -o */ + // {"--value", 'p', RTGETOPT_REQ_STRING} /* only with -i */ + if (fOptionsRead) + return errorSyntax(USAGE_DHCPSERVER, + "previos option edition wasn't finished"); + fOptionsRead = true; + fVmOptionRead = false; /* we want specify new global or vm option*/ + u8Slot = (uint8_t)~0; + u8OptId = (uint8_t)~0; + pszVmName = NULL; + } /* end of --options */ + break; + + case 'M': // --vm + { + if (fVmOptionRead) + return errorSyntax(USAGE_DHCPSERVER, + "previous vm option edition wasn't finished"); + else + fVmOptionRead = true; + u8Slot = (uint8_t)~0; /* clear slor */ + pszVmName = RTStrDup(ValueUnion.psz); + } + break; /* end of --vm */ + + case 'n': // --nic + { + if (!fVmOptionRead) + return errorSyntax(USAGE_DHCPSERVER, + "vm name wasn't specified"); + + u8Slot = ValueUnion.u8; + + if (u8Slot < 1) + return errorSyntax(USAGE_DHCPSERVER, + "invalid NIC number: %u", u8Slot); + --u8Slot; + } + break; /* end of --nic */ + + case 'i': // --id + { + if (!fOptionsRead) + return errorSyntax(USAGE_DHCPSERVER, + "-o wasn't found"); + + u8OptId = ValueUnion.u8; + } + break; /* end of --id */ + + case 'p': // --value + { + if (!fOptionsRead) + return errorSyntax(USAGE_DHCPSERVER, + "-o wasn't found"); + + if (u8OptId == (uint8_t)~0) + return errorSyntax(USAGE_DHCPSERVER, + "--id wasn't found"); + if ( fVmOptionRead + && u8Slot == (uint8_t)~0) + return errorSyntax(USAGE_DHCPSERVER, + "--nic wasn't found"); + + DhcpOpts &opts = fVmOptionRead ? VmSlot2Options[VmNameSlotKey(pszVmName, u8Slot)] + : GlobalDhcpOptions; + std::string strVal = ValueUnion.psz; + opts.push_back(DhcpOptSpec((DhcpOpt_T)u8OptId, strVal)); + + } + break; // --end of value + + case 'r': /* --remove */ + { + if (!fOptionsRead) + return errorSyntax(USAGE_DHCPSERVER, + "-o wasn't found"); + + if (u8OptId == (uint8_t)~0) + return errorSyntax(USAGE_DHCPSERVER, + "--id wasn't found"); + if ( fVmOptionRead + && u8Slot == (uint8_t)~0) + return errorSyntax(USAGE_DHCPSERVER, + "--nic wasn't found"); + + DhcpOptIds &optIds = fVmOptionRead ? VmSlot2Options2Delete[VmNameSlotKey(pszVmName, u8Slot)] + : GlobalDhcpOptions2Delete; + optIds.push_back((DhcpOpt_T)u8OptId); + } + break; /* --end of remove */ + + default: + if (c > 0) + { + if (RT_C_IS_GRAPH(c)) + return errorSyntax(USAGE_DHCPSERVER, "unhandled option: -%c", c); + return errorSyntax(USAGE_DHCPSERVER, "unhandled option: %i", c); + } + if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_DHCPSERVER, "unknown option: %s", ValueUnion.psz); + if (ValueUnion.pDef) + return errorSyntax(USAGE_DHCPSERVER, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + return errorSyntax(USAGE_DHCPSERVER, "%Rrs", c); + } + } + + if(! pNetName && !pIfName) + return errorSyntax(USAGE_DHCPSERVER, "You need to specify either --netname or --ifname to identify the DHCP server"); + + if( enmCode != OP_REMOVE + && enmCode != OP_RESTART + && GlobalDhcpOptions.empty() + && VmSlot2Options.empty() + && GlobalDhcpOptions2Delete.empty() + && VmSlot2Options2Delete.empty()) + { + if(enable < 0 || pIp || pNetmask || pLowerIp || pUpperIp) + { + if(!pIp) + return errorSyntax(USAGE_DHCPSERVER, "You need to specify --ip option"); + + if(!pNetmask) + return errorSyntax(USAGE_DHCPSERVER, "You need to specify --netmask option"); + + if(!pLowerIp) + return errorSyntax(USAGE_DHCPSERVER, "You need to specify --lowerip option"); + + if(!pUpperIp) + return errorSyntax(USAGE_DHCPSERVER, "You need to specify --upperip option"); + } + } + + Bstr NetName; + if(!pNetName) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + + ComPtr<IHostNetworkInterface> hif; + CHECK_ERROR(host, FindHostNetworkInterfaceByName(Bstr(pIfName).mutableRaw(), hif.asOutParam())); + if (FAILED(rc)) + return errorArgument("Could not find interface '%s'", pIfName); + + CHECK_ERROR(hif, COMGETTER(NetworkName) (NetName.asOutParam())); + if (FAILED(rc)) + return errorArgument("Could not get network name for the interface '%s'", pIfName); + } + else + { + NetName = Bstr(pNetName); + } + + ComPtr<IDHCPServer> svr; + rc = a->virtualBox->FindDHCPServerByNetworkName(NetName.mutableRaw(), svr.asOutParam()); + if(enmCode == OP_ADD) + { + if (SUCCEEDED(rc)) + return errorArgument("DHCP server already exists"); + + CHECK_ERROR(a->virtualBox, CreateDHCPServer(NetName.mutableRaw(), svr.asOutParam())); + if (FAILED(rc)) + return errorArgument("Failed to create the DHCP server"); + } + else if (FAILED(rc)) + { + return errorArgument("DHCP server does not exist"); + } + + if (enmCode == OP_RESTART) + { + CHECK_ERROR(svr, Restart()); + if(FAILED(rc)) + return errorArgument("Failed to restart server"); + } + else if (enmCode == OP_REMOVE) + { + CHECK_ERROR(a->virtualBox, RemoveDHCPServer(svr)); + if(FAILED(rc)) + return errorArgument("Failed to remove server"); + } + else + { + if (pIp || pNetmask || pLowerIp || pUpperIp) + { + CHECK_ERROR(svr, SetConfiguration ( + Bstr(pIp).mutableRaw(), + Bstr(pNetmask).mutableRaw(), + Bstr(pLowerIp).mutableRaw(), + Bstr(pUpperIp).mutableRaw())); + if(FAILED(rc)) + return errorArgument("Failed to set configuration"); + } + + if(enable >= 0) + { + CHECK_ERROR(svr, COMSETTER(Enabled) ((BOOL)enable)); + } + + /* remove specified options */ + DhcpOptIdIterator itOptId; + for (itOptId = GlobalDhcpOptions2Delete.begin(); + itOptId != GlobalDhcpOptions2Delete.end(); + ++itOptId) + { + CHECK_ERROR(svr, RemoveGlobalOption(*itOptId)); + } + VmSlot2OptionIdsIterator itIdVector; + for (itIdVector = VmSlot2Options2Delete.begin(); + itIdVector != VmSlot2Options2Delete.end(); + ++itIdVector) + { + for(itOptId = itIdVector->second.begin(); + itOptId != itIdVector->second.end(); + ++itOptId) + { + CHECK_ERROR(svr, + RemoveVmSlotOption(Bstr(itIdVector->first.VmName.c_str()).raw(), + itIdVector->first.u8Slot, + *itOptId)); + } + } + + /* option processing */ + DhcpOptIterator itOpt; + VmSlot2OptionsIterator it; + + /* Global Options */ + for(itOpt = GlobalDhcpOptions.begin(); + itOpt != GlobalDhcpOptions.end(); + ++itOpt) + { + CHECK_ERROR(svr, + AddGlobalOption( + itOpt->first, + com::Bstr(itOpt->second.c_str()).raw())); + } + + /* heh, vm slot options. */ + + for (it = VmSlot2Options.begin(); + it != VmSlot2Options.end(); + ++it) + { + for(itOpt = it->second.begin(); + itOpt != it->second.end(); + ++itOpt) + { + CHECK_ERROR(svr, + AddVmSlotOption(Bstr(it->first.VmName.c_str()).raw(), + it->first.u8Slot, + itOpt->first, + com::Bstr(itOpt->second.c_str()).raw())); + } + } + } + + return RTEXITCODE_SUCCESS; +} + + +RTEXITCODE handleDHCPServer(HandlerArg *a) +{ + if (a->argc < 1) + return errorSyntax(USAGE_DHCPSERVER, "Not enough parameters"); + + RTEXITCODE rcExit; + if (strcmp(a->argv[0], "modify") == 0) + rcExit = handleOp(a, OP_MODIFY, 1); + else if (strcmp(a->argv[0], "add") == 0) + rcExit = handleOp(a, OP_ADD, 1); + else if (strcmp(a->argv[0], "remove") == 0) + rcExit = handleOp(a, OP_REMOVE, 1); + else if (strcmp(a->argv[0], "restart") == 0) + rcExit = handleOp(a, OP_RESTART, 1); + else + rcExit = errorSyntax(USAGE_DHCPSERVER, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str()); + + return rcExit; +} + +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp new file mode 100644 index 00000000..5efaa0ad --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp @@ -0,0 +1,899 @@ +/* $Id: VBoxManageDebugVM.cpp $ */ +/** @file + * VBoxManage - Implementation of the debugvm command. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <VBox/types.h> +#include <iprt/ctype.h> +#include <iprt/getopt.h> +#include <iprt/path.h> +#include <iprt/param.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/uuid.h> +#include <VBox/log.h> + +#include "VBoxManage.h" + + +/** + * Handles the getregisters sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_GetRegisters(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * We take a list of register names (case insensitive). If 'all' is + * encountered we'll dump all registers. + */ + ULONG idCpu = 0; + unsigned cRegisters = 0; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--cpu", 'c', RTGETOPT_REQ_UINT32 }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'c': + idCpu = ValueUnion.u32; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!RTStrICmp(ValueUnion.psz, "all")) + { + com::SafeArray<BSTR> aBstrNames; + com::SafeArray<BSTR> aBstrValues; + CHECK_ERROR2I_RET(pDebugger, GetRegisters(idCpu, ComSafeArrayAsOutParam(aBstrNames), + ComSafeArrayAsOutParam(aBstrValues)), + RTEXITCODE_FAILURE); + Assert(aBstrNames.size() == aBstrValues.size()); + + size_t cchMaxName = 8; + for (size_t i = 0; i < aBstrNames.size(); i++) + { + size_t cchName = RTUtf16Len(aBstrNames[i]); + if (cchName > cchMaxName) + cchMaxName = cchName; + } + + for (size_t i = 0; i < aBstrNames.size(); i++) + RTPrintf("%-*ls = %ls\n", cchMaxName, aBstrNames[i], aBstrValues[i]); + } + else + { + com::Bstr bstrName = ValueUnion.psz; + com::Bstr bstrValue; + CHECK_ERROR2I_RET(pDebugger, GetRegister(idCpu, bstrName.raw(), bstrValue.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("%s = %ls\n", ValueUnion.psz, bstrValue.raw()); + } + cRegisters++; + break; + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + if (!cRegisters) + return errorSyntax("The getregisters sub-command takes at least one register name"); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the info sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_Info(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse arguments. + */ + const char *pszInfo = NULL; + const char *pszArgs = NULL; + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, NULL, 0, 2, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case VINF_GETOPT_NOT_OPTION: + if (!pszInfo) + pszInfo = ValueUnion.psz; + else if (!pszArgs) + pszArgs = ValueUnion.psz; + else + return errorTooManyParameters(&pArgs->argv[GetState.iNext - 1]); + break; + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + if (!pszInfo) + return errorSyntax("Must specify info item to display"); + + /* + * Do the work. + */ + com::Bstr bstrName(pszInfo); + com::Bstr bstrArgs(pszArgs); + com::Bstr bstrInfo; + CHECK_ERROR2I_RET(pDebugger, Info(bstrName.raw(), bstrArgs.raw(), bstrInfo.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("%ls", bstrInfo.raw()); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the inject sub-command. + * + * @returns Suitable exit code. + * @param a The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_InjectNMI(HandlerArg *a, IMachineDebugger *pDebugger) +{ + if (a->argc != 2) + return errorTooManyParameters(&a->argv[1]); + CHECK_ERROR2I_RET(pDebugger, InjectNMI(), RTEXITCODE_FAILURE); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the log sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + * @param pszSubCmd The sub command. + */ +static RTEXITCODE handleDebugVM_LogXXXX(HandlerArg *pArgs, IMachineDebugger *pDebugger, const char *pszSubCmd) +{ + /* + * Parse arguments. + */ + bool fRelease = false; + com::Utf8Str strSettings; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + + /* + * NB: don't use short options to prevent log specifications like + * "-drv_foo" from being interpreted as options. + */ +# define DEBUGVM_LOG_DEBUG (VINF_GETOPT_NOT_OPTION + 'd') +# define DEBUGVM_LOG_RELEASE (VINF_GETOPT_NOT_OPTION + 'r') + + static const RTGETOPTDEF s_aOptions[] = + { + { "--debug", DEBUGVM_LOG_DEBUG, RTGETOPT_REQ_NOTHING }, + { "--release", DEBUGVM_LOG_RELEASE, RTGETOPT_REQ_NOTHING } + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, + /* + * Note: RTGETOPTINIT_FLAGS_NO_STD_OPTS is needed to not get into an infinite hang in the following + * while-loop when processing log groups starting with "h", + * e.g. "VBoxManage debugvm <VM Name> log --debug -hex". + */ + RTGETOPTINIT_FLAGS_OPTS_FIRST | RTGETOPTINIT_FLAGS_NO_STD_OPTS); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case DEBUGVM_LOG_RELEASE: + fRelease = true; + break; + + case DEBUGVM_LOG_DEBUG: + fRelease = false; + break; + + /* Because log strings can start with "-" (like "-all+dev_foo") + * we have to take everything we got as a setting and apply it. + * IPRT will take care of the validation afterwards. */ + default: + if (strSettings.length() == 0) + strSettings = ValueUnion.psz; + else + { + strSettings.append(' '); + strSettings.append(ValueUnion.psz); + } + break; + } + } + + if (fRelease) + { + com::Utf8Str strTmp(strSettings); + strSettings = "release:"; + strSettings.append(strTmp); + } + + com::Bstr bstrSettings(strSettings); + if (!strcmp(pszSubCmd, "log")) + CHECK_ERROR2I_RET(pDebugger, ModifyLogGroups(bstrSettings.raw()), RTEXITCODE_FAILURE); + else if (!strcmp(pszSubCmd, "logdest")) + CHECK_ERROR2I_RET(pDebugger, ModifyLogDestinations(bstrSettings.raw()), RTEXITCODE_FAILURE); + else if (!strcmp(pszSubCmd, "logflags")) + CHECK_ERROR2I_RET(pDebugger, ModifyLogFlags(bstrSettings.raw()), RTEXITCODE_FAILURE); + else + AssertFailedReturn(RTEXITCODE_FAILURE); + + return RTEXITCODE_SUCCESS; +} + + +/** + * Handles the inject sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_DumpVMCore(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse arguments. + */ + const char *pszFilename = NULL; + const char *pszCompression = NULL; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--filename", 'f', RTGETOPT_REQ_STRING }, + { "--compression", 'c', RTGETOPT_REQ_STRING } + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'c': + if (pszCompression) + return errorSyntax("The --compression option has already been given"); + pszCompression = ValueUnion.psz; + break; + case 'f': + if (pszFilename) + return errorSyntax("The --filename option has already been given"); + pszFilename = ValueUnion.psz; + break; + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + if (!pszFilename) + return errorSyntax("The --filename option is required"); + + /* + * Make the filename absolute before handing it on to the API. + */ + char szAbsFilename[RTPATH_MAX]; + rc = RTPathAbs(pszFilename, szAbsFilename, sizeof(szAbsFilename)); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed on '%s': %Rrc", pszFilename, rc); + + com::Bstr bstrFilename(szAbsFilename); + com::Bstr bstrCompression(pszCompression); + CHECK_ERROR2I_RET(pDebugger, DumpGuestCore(bstrFilename.raw(), bstrCompression.raw()), RTEXITCODE_FAILURE); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the osdetect sub-command. + * + * @returns Suitable exit code. + * @param a The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_OSDetect(HandlerArg *a, IMachineDebugger *pDebugger) +{ + if (a->argc != 2) + return errorTooManyParameters(&a->argv[1]); + + com::Bstr bstrIgnore; + com::Bstr bstrAll("all"); + CHECK_ERROR2I_RET(pDebugger, LoadPlugIn(bstrAll.raw(), bstrIgnore.asOutParam()), RTEXITCODE_FAILURE); + + com::Bstr bstrName; + CHECK_ERROR2I_RET(pDebugger, DetectOS(bstrName.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("Detected: %ls\n", bstrName.raw()); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the osinfo sub-command. + * + * @returns Suitable exit code. + * @param a The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_OSInfo(HandlerArg *a, IMachineDebugger *pDebugger) +{ + if (a->argc != 2) + return errorTooManyParameters(&a->argv[1]); + + com::Bstr bstrName; + CHECK_ERROR2I_RET(pDebugger, COMGETTER(OSName)(bstrName.asOutParam()), RTEXITCODE_FAILURE); + com::Bstr bstrVersion; + CHECK_ERROR2I_RET(pDebugger, COMGETTER(OSVersion)(bstrVersion.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("Name: %ls\n", bstrName.raw()); + RTPrintf("Version: %ls\n", bstrVersion.raw()); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the osdmsg sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_OSDmesg(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse argument. + */ + uint32_t uMaxMessages = 0; + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--lines", 'n', RTGETOPT_REQ_UINT32 }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + switch (rc) + { + case 'n': uMaxMessages = ValueUnion.u32; break; + default: return errorGetOpt(rc, &ValueUnion); + } + + /* + * Do it. + */ + com::Bstr bstrDmesg; + CHECK_ERROR2I_RET(pDebugger, QueryOSKernelLog(uMaxMessages, bstrDmesg.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("%ls\n", bstrDmesg.raw()); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the setregisters sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_SetRegisters(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * We take a list of register assignments, that is register=value. + */ + ULONG idCpu = 0; + com::SafeArray<IN_BSTR> aBstrNames; + com::SafeArray<IN_BSTR> aBstrValues; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--cpu", 'c', RTGETOPT_REQ_UINT32 }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'c': + idCpu = ValueUnion.u32; + break; + + case VINF_GETOPT_NOT_OPTION: + { + const char *pszEqual = strchr(ValueUnion.psz, '='); + if (!pszEqual) + return errorSyntax("setregisters expects input on the form 'register=value' got '%s'", ValueUnion.psz); + try + { + com::Bstr bstrName(ValueUnion.psz, pszEqual - ValueUnion.psz); + com::Bstr bstrValue(pszEqual + 1); + if ( !aBstrNames.push_back(bstrName.raw()) + || !aBstrValues.push_back(bstrValue.raw())) + throw std::bad_alloc(); + } + catch (std::bad_alloc &) + { + RTMsgError("Out of memory\n"); + return RTEXITCODE_FAILURE; + } + break; + } + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + if (!aBstrNames.size()) + return errorSyntax("The setregisters sub-command takes at least one register name"); + + /* + * If it is only one register, use the single register method just so + * we expose it and can test it from the command line. + */ + if (aBstrNames.size() == 1) + { + CHECK_ERROR2I_RET(pDebugger, SetRegister(idCpu, aBstrNames[0], aBstrValues[0]), RTEXITCODE_FAILURE); + RTPrintf("Successfully set %ls\n", aBstrNames[0]); + } + else + { + CHECK_ERROR2I_RET(pDebugger, SetRegisters(idCpu, ComSafeArrayAsInParam(aBstrNames), ComSafeArrayAsInParam(aBstrValues)), + RTEXITCODE_FAILURE); + RTPrintf("Successfully set %u registers\n", aBstrNames.size()); + } + + return RTEXITCODE_SUCCESS; +} + +/** @name debugvm show flags + * @{ */ +#define DEBUGVM_SHOW_FLAGS_HUMAN_READABLE UINT32_C(0x00000000) +#define DEBUGVM_SHOW_FLAGS_SH_EXPORT UINT32_C(0x00000001) +#define DEBUGVM_SHOW_FLAGS_SH_EVAL UINT32_C(0x00000002) +#define DEBUGVM_SHOW_FLAGS_CMD_SET UINT32_C(0x00000003) +#define DEBUGVM_SHOW_FLAGS_FMT_MASK UINT32_C(0x00000003) +/** @} */ + +/** + * Prints a variable according to the @a fFlags. + * + * @param pszVar The variable name. + * @param pbstrValue The variable value. + * @param fFlags The debugvm show flags. + */ +static void handleDebugVM_Show_PrintVar(const char *pszVar, com::Bstr const *pbstrValue, uint32_t fFlags) +{ + switch (fFlags & DEBUGVM_SHOW_FLAGS_FMT_MASK) + { + case DEBUGVM_SHOW_FLAGS_HUMAN_READABLE: RTPrintf(" %27s=%ls\n", pszVar, pbstrValue->raw()); break; + case DEBUGVM_SHOW_FLAGS_SH_EXPORT: RTPrintf("export %s='%ls'\n", pszVar, pbstrValue->raw()); break; + case DEBUGVM_SHOW_FLAGS_SH_EVAL: RTPrintf("%s='%ls'\n", pszVar, pbstrValue->raw()); break; + case DEBUGVM_SHOW_FLAGS_CMD_SET: RTPrintf("set %s=%ls\n", pszVar, pbstrValue->raw()); break; + default: AssertFailed(); + } +} + +/** + * Handles logdbg-settings. + * + * @returns Exit code. + * @param pDebugger The debugger interface. + * @param fFlags The debugvm show flags. + */ +static RTEXITCODE handleDebugVM_Show_LogDbgSettings(IMachineDebugger *pDebugger, uint32_t fFlags) +{ + if ((fFlags & DEBUGVM_SHOW_FLAGS_FMT_MASK) == DEBUGVM_SHOW_FLAGS_HUMAN_READABLE) + RTPrintf("Debug logger settings:\n"); + + com::Bstr bstr; + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogDbgGroups)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_LOG", &bstr, fFlags); + + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogDbgFlags)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_LOG_FLAGS", &bstr, fFlags); + + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogDbgDestinations)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_LOG_DEST", &bstr, fFlags); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles logrel-settings. + * + * @returns Exit code. + * @param pDebugger The debugger interface. + * @param fFlags The debugvm show flags. + */ +static RTEXITCODE handleDebugVM_Show_LogRelSettings(IMachineDebugger *pDebugger, uint32_t fFlags) +{ + if ((fFlags & DEBUGVM_SHOW_FLAGS_FMT_MASK) == DEBUGVM_SHOW_FLAGS_HUMAN_READABLE) + RTPrintf("Release logger settings:\n"); + + com::Bstr bstr; + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogRelGroups)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_RELEASE_LOG", &bstr, fFlags); + + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogRelFlags)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_RELEASE_LOG_FLAGS", &bstr, fFlags); + + CHECK_ERROR2I_RET(pDebugger, COMGETTER(LogRelDestinations)(bstr.asOutParam()), RTEXITCODE_FAILURE); + handleDebugVM_Show_PrintVar("VBOX_RELEASE_LOG_DEST", &bstr, fFlags); + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the show sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_Show(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse arguments and what to show. Order dependent. + */ + uint32_t fFlags = DEBUGVM_SHOW_FLAGS_HUMAN_READABLE; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--human-readable", 'H', RTGETOPT_REQ_NOTHING }, + { "--sh-export", 'e', RTGETOPT_REQ_NOTHING }, + { "--sh-eval", 'E', RTGETOPT_REQ_NOTHING }, + { "--cmd-set", 's', RTGETOPT_REQ_NOTHING }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'H': + fFlags = (fFlags & ~DEBUGVM_SHOW_FLAGS_FMT_MASK) | DEBUGVM_SHOW_FLAGS_HUMAN_READABLE; + break; + + case 'e': + fFlags = (fFlags & ~DEBUGVM_SHOW_FLAGS_FMT_MASK) | DEBUGVM_SHOW_FLAGS_SH_EXPORT; + break; + + case 'E': + fFlags = (fFlags & ~DEBUGVM_SHOW_FLAGS_FMT_MASK) | DEBUGVM_SHOW_FLAGS_SH_EVAL; + break; + + case 's': + fFlags = (fFlags & ~DEBUGVM_SHOW_FLAGS_FMT_MASK) | DEBUGVM_SHOW_FLAGS_CMD_SET; + break; + + case VINF_GETOPT_NOT_OPTION: + { + RTEXITCODE rcExit; + if (!strcmp(ValueUnion.psz, "log-settings")) + { + rcExit = handleDebugVM_Show_LogDbgSettings(pDebugger, fFlags); + if (rcExit == RTEXITCODE_SUCCESS) + rcExit = handleDebugVM_Show_LogRelSettings(pDebugger, fFlags); + } + else if (!strcmp(ValueUnion.psz, "logdbg-settings")) + rcExit = handleDebugVM_Show_LogDbgSettings(pDebugger, fFlags); + else if (!strcmp(ValueUnion.psz, "logrel-settings")) + rcExit = handleDebugVM_Show_LogRelSettings(pDebugger, fFlags); + else + rcExit = errorSyntax("The show sub-command has no idea what '%s' might be", ValueUnion.psz); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + break; + } + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the stack sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_Stack(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse arguments. + */ + VMCPUID idCpu = VMCPUID_ALL; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--cpu", 'c', RTGETOPT_REQ_UINT32 }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'c': + idCpu = ValueUnion.u32; + break; + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + /* + * Dump stack. + */ + com::Bstr bstrGuestStack; + if (idCpu != VMCPUID_ALL) + { + /* Single CPU */ + CHECK_ERROR2I_RET(pDebugger, DumpGuestStack(idCpu, bstrGuestStack.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("%ls\n", bstrGuestStack.raw()); + } + else + { + /* All CPUs. */ + ComPtr<IMachine> ptrMachine; + CHECK_ERROR2I_RET(pArgs->session, COMGETTER(Machine)(ptrMachine.asOutParam()), RTEXITCODE_FAILURE); + ULONG cCpus; + CHECK_ERROR2I_RET(ptrMachine, COMGETTER(CPUCount)(&cCpus), RTEXITCODE_FAILURE); + + for (idCpu = 0; idCpu < (VMCPUID)cCpus; idCpu++) + { + CHECK_ERROR2I_RET(pDebugger, DumpGuestStack(idCpu, bstrGuestStack.asOutParam()), RTEXITCODE_FAILURE); + if (cCpus > 1) + { + if (idCpu > 0) + RTPrintf("\n"); + RTPrintf("====================== CPU #%u ======================\n", idCpu); + } + RTPrintf("%ls\n", bstrGuestStack.raw()); + } + } + + + return RTEXITCODE_SUCCESS; +} + +/** + * Handles the statistics sub-command. + * + * @returns Suitable exit code. + * @param pArgs The handler arguments. + * @param pDebugger Pointer to the debugger interface. + */ +static RTEXITCODE handleDebugVM_Statistics(HandlerArg *pArgs, IMachineDebugger *pDebugger) +{ + /* + * Parse arguments. + */ + bool fWithDescriptions = false; + const char *pszPattern = NULL; /* all */ + bool fReset = false; + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + static const RTGETOPTDEF s_aOptions[] = + { + { "--descriptions", 'd', RTGETOPT_REQ_NOTHING }, + { "--pattern", 'p', RTGETOPT_REQ_STRING }, + { "--reset", 'r', RTGETOPT_REQ_NOTHING }, + }; + int rc = RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 2, 0 /*fFlags*/); + AssertRCReturn(rc, RTEXITCODE_FAILURE); + + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + case 'd': + fWithDescriptions = true; + break; + + case 'p': + if (pszPattern) + return errorSyntax("Multiple --pattern options are not permitted"); + pszPattern = ValueUnion.psz; + break; + + case 'r': + fReset = true; + break; + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + if (fReset && fWithDescriptions) + return errorSyntax("The --reset and --descriptions options does not mix"); + + /* + * Execute the order. + */ + com::Bstr bstrPattern(pszPattern); + if (fReset) + CHECK_ERROR2I_RET(pDebugger, ResetStats(bstrPattern.raw()), RTEXITCODE_FAILURE); + else + { + com::Bstr bstrStats; + CHECK_ERROR2I_RET(pDebugger, GetStats(bstrPattern.raw(), fWithDescriptions, bstrStats.asOutParam()), + RTEXITCODE_FAILURE); + /* if (fFormatted) + { big mess } + else + */ + RTPrintf("%ls\n", bstrStats.raw()); + } + + return RTEXITCODE_SUCCESS; +} + +RTEXITCODE handleDebugVM(HandlerArg *pArgs) +{ + RTEXITCODE rcExit = RTEXITCODE_FAILURE; + + /* + * The first argument is the VM name or UUID. Open a session to it. + */ + if (pArgs->argc < 2) + return errorNoSubcommand(); + ComPtr<IMachine> ptrMachine; + CHECK_ERROR2I_RET(pArgs->virtualBox, FindMachine(com::Bstr(pArgs->argv[0]).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR2I_RET(ptrMachine, LockMachine(pArgs->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* + * Get the associated console and machine debugger. + */ + HRESULT hrc; + ComPtr<IConsole> ptrConsole; + CHECK_ERROR2(hrc, pArgs->session, COMGETTER(Console)(ptrConsole.asOutParam())); + if (SUCCEEDED(hrc)) + { + if (ptrConsole.isNotNull()) + { + ComPtr<IMachineDebugger> ptrDebugger; + CHECK_ERROR2(hrc, ptrConsole, COMGETTER(Debugger)(ptrDebugger.asOutParam())); + if (SUCCEEDED(hrc)) + { + /* + * String switch on the sub-command. + */ + const char *pszSubCmd = pArgs->argv[1]; + if (!strcmp(pszSubCmd, "dumpvmcore")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_DUMPVMCORE); + rcExit = handleDebugVM_DumpVMCore(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "getregisters")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_GETREGISTERS); + rcExit = handleDebugVM_GetRegisters(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "info")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_INFO); + rcExit = handleDebugVM_Info(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "injectnmi")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_INJECTNMI); + rcExit = handleDebugVM_InjectNMI(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "log")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_LOG); + rcExit = handleDebugVM_LogXXXX(pArgs, ptrDebugger, pszSubCmd); + } + else if (!strcmp(pszSubCmd, "logdest")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_LOGDEST); + rcExit = handleDebugVM_LogXXXX(pArgs, ptrDebugger, pszSubCmd); + } + else if (!strcmp(pszSubCmd, "logflags")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_LOGFLAGS); + rcExit = handleDebugVM_LogXXXX(pArgs, ptrDebugger, pszSubCmd); + } + else if (!strcmp(pszSubCmd, "osdetect")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_OSDETECT); + rcExit = handleDebugVM_OSDetect(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "osinfo")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_OSINFO); + rcExit = handleDebugVM_OSInfo(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "osdmesg")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_OSDMESG); + rcExit = handleDebugVM_OSDmesg(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "setregisters")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_SETREGISTERS); + rcExit = handleDebugVM_SetRegisters(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "show")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_SHOW); + rcExit = handleDebugVM_Show(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "stack")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_STACK); + rcExit = handleDebugVM_Stack(pArgs, ptrDebugger); + } + else if (!strcmp(pszSubCmd, "statistics")) + { + setCurrentSubcommand(HELP_SCOPE_DEBUGVM_STATISTICS); + rcExit = handleDebugVM_Statistics(pArgs, ptrDebugger); + } + else + errorUnknownSubcommand(pszSubCmd); + } + } + else + RTMsgError("Machine '%s' is not currently running.\n", pArgs->argv[0]); + } + + pArgs->session->UnlockMachine(); + + return rcExit; +} + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp new file mode 100644 index 00000000..ef4db168 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp @@ -0,0 +1,2560 @@ +/* $Id: VBoxManageDisk.cpp $ */ +/** @file + * VBoxManage - The disk/medium related commands. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/asm.h> +#include <iprt/file.h> +#include <iprt/path.h> +#include <iprt/param.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/ctype.h> +#include <iprt/getopt.h> +#include <VBox/log.h> +#include <VBox/vd.h> + +#include "VBoxManage.h" +using namespace com; + +/** Medium category. */ +typedef enum MEDIUMCATEGORY +{ + MEDIUMCATEGORY_NONE = 0, + MEDIUMCATEGORY_DISK, + MEDIUMCATEGORY_DVD, + MEDIUMCATEGORY_FLOPPY +} MEDIUMCATEGORY; + + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + + +static DECLCALLBACK(void) handleVDError(void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) +{ + RT_NOREF(pvUser); + RTMsgErrorV(pszFormat, va); + RTMsgError("Error code %Rrc at %s(%u) in function %s", rc, RT_SRC_POS_ARGS); +} + +static int parseMediumVariant(const char *psz, MediumVariant_T *pMediumVariant) +{ + int rc = VINF_SUCCESS; + unsigned uMediumVariant = (unsigned)(*pMediumVariant); + while (psz && *psz && RT_SUCCESS(rc)) + { + size_t len; + const char *pszComma = strchr(psz, ','); + if (pszComma) + len = pszComma - psz; + else + len = strlen(psz); + if (len > 0) + { + // Parsing is intentionally inconsistent: "standard" resets the + // variant, whereas the other flags are cumulative. + if (!RTStrNICmp(psz, "standard", len)) + uMediumVariant = MediumVariant_Standard; + else if ( !RTStrNICmp(psz, "fixed", len) + || !RTStrNICmp(psz, "static", len)) + uMediumVariant |= MediumVariant_Fixed; + else if (!RTStrNICmp(psz, "Diff", len)) + uMediumVariant |= MediumVariant_Diff; + else if (!RTStrNICmp(psz, "split2g", len)) + uMediumVariant |= MediumVariant_VmdkSplit2G; + else if ( !RTStrNICmp(psz, "stream", len) + || !RTStrNICmp(psz, "streamoptimized", len)) + uMediumVariant |= MediumVariant_VmdkStreamOptimized; + else if (!RTStrNICmp(psz, "esx", len)) + uMediumVariant |= MediumVariant_VmdkESX; + else if (!RTStrNICmp(psz, "formatted", len)) + uMediumVariant |= MediumVariant_Formatted; + else + rc = VERR_PARSE_ERROR; + } + if (pszComma) + psz += len + 1; + else + psz += len; + } + + if (RT_SUCCESS(rc)) + *pMediumVariant = (MediumVariant_T)uMediumVariant; + return rc; +} + +int parseMediumType(const char *psz, MediumType_T *penmMediumType) +{ + int rc = VINF_SUCCESS; + MediumType_T enmMediumType = MediumType_Normal; + if (!RTStrICmp(psz, "normal")) + enmMediumType = MediumType_Normal; + else if (!RTStrICmp(psz, "immutable")) + enmMediumType = MediumType_Immutable; + else if (!RTStrICmp(psz, "writethrough")) + enmMediumType = MediumType_Writethrough; + else if (!RTStrICmp(psz, "shareable")) + enmMediumType = MediumType_Shareable; + else if (!RTStrICmp(psz, "readonly")) + enmMediumType = MediumType_Readonly; + else if (!RTStrICmp(psz, "multiattach")) + enmMediumType = MediumType_MultiAttach; + else + rc = VERR_PARSE_ERROR; + + if (RT_SUCCESS(rc)) + *penmMediumType = enmMediumType; + return rc; +} + +/** @todo move this into getopt, as getting bool values is generic */ +int parseBool(const char *psz, bool *pb) +{ + int rc = VINF_SUCCESS; + if ( !RTStrICmp(psz, "on") + || !RTStrICmp(psz, "yes") + || !RTStrICmp(psz, "true") + || !RTStrICmp(psz, "1") + || !RTStrICmp(psz, "enable") + || !RTStrICmp(psz, "enabled")) + { + *pb = true; + } + else if ( !RTStrICmp(psz, "off") + || !RTStrICmp(psz, "no") + || !RTStrICmp(psz, "false") + || !RTStrICmp(psz, "0") + || !RTStrICmp(psz, "disable") + || !RTStrICmp(psz, "disabled")) + { + *pb = false; + } + else + rc = VERR_PARSE_ERROR; + + return rc; +} + +HRESULT openMedium(HandlerArg *a, const char *pszFilenameOrUuid, + DeviceType_T enmDevType, AccessMode_T enmAccessMode, + ComPtr<IMedium> &pMedium, bool fForceNewUuidOnOpen, + bool fSilent) +{ + HRESULT rc; + Guid id(pszFilenameOrUuid); + char szFilenameAbs[RTPATH_MAX] = ""; + + /* If it is no UUID, convert the filename to an absolute one. */ + if (!id.isValid()) + { + int irc = RTPathAbs(pszFilenameOrUuid, szFilenameAbs, sizeof(szFilenameAbs)); + if (RT_FAILURE(irc)) + { + if (!fSilent) + RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilenameOrUuid); + return E_FAIL; + } + pszFilenameOrUuid = szFilenameAbs; + } + + if (!fSilent) + CHECK_ERROR(a->virtualBox, OpenMedium(Bstr(pszFilenameOrUuid).raw(), + enmDevType, + enmAccessMode, + fForceNewUuidOnOpen, + pMedium.asOutParam())); + else + rc = a->virtualBox->OpenMedium(Bstr(pszFilenameOrUuid).raw(), + enmDevType, + enmAccessMode, + fForceNewUuidOnOpen, + pMedium.asOutParam()); + + return rc; +} + +static HRESULT createMedium(HandlerArg *a, const char *pszFormat, + const char *pszFilename, DeviceType_T enmDevType, + AccessMode_T enmAccessMode, ComPtr<IMedium> &pMedium) +{ + HRESULT rc; + char szFilenameAbs[RTPATH_MAX] = ""; + + /** @todo laziness shortcut. should really check the MediumFormatCapabilities */ + if (RTStrICmp(pszFormat, "iSCSI")) + { + int irc = RTPathAbs(pszFilename, szFilenameAbs, sizeof(szFilenameAbs)); + if (RT_FAILURE(irc)) + { + RTMsgError("Cannot convert filename \"%s\" to absolute path", pszFilename); + return E_FAIL; + } + pszFilename = szFilenameAbs; + } + + CHECK_ERROR(a->virtualBox, CreateMedium(Bstr(pszFormat).raw(), + Bstr(pszFilename).raw(), + enmAccessMode, + enmDevType, + pMedium.asOutParam())); + return rc; +} + +static const RTGETOPTDEF g_aCreateMediumOptions[] = +{ + { "disk", 'H', RTGETOPT_REQ_NOTHING }, + { "dvd", 'D', RTGETOPT_REQ_NOTHING }, + { "floppy", 'L', RTGETOPT_REQ_NOTHING }, + { "--filename", 'f', RTGETOPT_REQ_STRING }, + { "-filename", 'f', RTGETOPT_REQ_STRING }, // deprecated + { "--diffparent", 'd', RTGETOPT_REQ_STRING }, + { "--size", 's', RTGETOPT_REQ_UINT64 }, + { "-size", 's', RTGETOPT_REQ_UINT64 }, // deprecated + { "--sizebyte", 'S', RTGETOPT_REQ_UINT64 }, + { "--format", 'o', RTGETOPT_REQ_STRING }, + { "-format", 'o', RTGETOPT_REQ_STRING }, // deprecated + { "--static", 'F', RTGETOPT_REQ_NOTHING }, + { "-static", 'F', RTGETOPT_REQ_NOTHING }, // deprecated + { "--variant", 'm', RTGETOPT_REQ_STRING }, + { "-variant", 'm', RTGETOPT_REQ_STRING }, // deprecated +}; + +RTEXITCODE handleCreateMedium(HandlerArg *a) +{ + HRESULT rc; + int vrc; + const char *filename = NULL; + const char *diffparent = NULL; + uint64_t size = 0; + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + const char *format = NULL; + bool fBase = true; + MediumVariant_T enmMediumVariant = MediumVariant_Standard; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateMediumOptions, RT_ELEMENTS(g_aCreateMediumOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'H': // disk + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DISK; + break; + + case 'D': // DVD + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DVD; + break; + + case 'L': // floppy + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CREATEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_FLOPPY; + break; + + case 'f': // --filename + filename = ValueUnion.psz; + break; + + case 'd': // --diffparent + diffparent = ValueUnion.psz; + fBase = false; + break; + + case 's': // --size + size = ValueUnion.u64 * _1M; + break; + + case 'S': // --sizebyte + size = ValueUnion.u64; + break; + + case 'o': // --format + format = ValueUnion.psz; + break; + + case 'F': // --static ("fixed"/"flat") + { + unsigned uMediumVariant = (unsigned)enmMediumVariant; + uMediumVariant |= MediumVariant_Fixed; + enmMediumVariant = (MediumVariant_T)uMediumVariant; + break; + } + + case 'm': // --variant + vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid medium variant '%s'", ValueUnion.psz); + break; + + case VINF_GETOPT_NOT_OPTION: + return errorSyntax(USAGE_CREATEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz); + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option -%c", c); + else + return errorSyntax(USAGE_CREATEMEDIUM, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_CREATEMEDIUM, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_CREATEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_CREATEMEDIUM, "error: %Rrs", c); + } + } + + /* check the outcome */ + if (cmd == CMD_NONE) + cmd = CMD_DISK; + ComPtr<IMedium> pParentMedium; + if (fBase) + { + if ( !filename + || !*filename + || size == 0) + return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename and --size are required"); + if (!format || !*format) + { + if (cmd == CMD_DISK) + format = "VDI"; + else if (cmd == CMD_DVD || cmd == CMD_FLOPPY) + { + format = "RAW"; + unsigned uMediumVariant = (unsigned)enmMediumVariant; + uMediumVariant |= MediumVariant_Fixed; + enmMediumVariant = (MediumVariant_T)uMediumVariant; + } + } + } + else + { + if ( !filename + || !*filename) + return errorSyntax(USAGE_CREATEMEDIUM, "Parameters --filename is required"); + size = 0; + if (cmd != CMD_DISK) + return errorSyntax(USAGE_CREATEMEDIUM, "Creating a differencing medium is only supported for hard disks"); + enmMediumVariant = MediumVariant_Diff; + if (!format || !*format) + { + const char *pszExt = RTPathSuffix(filename); + /* Skip over . if there is an extension. */ + if (pszExt) + pszExt++; + if (!pszExt || !*pszExt) + format = "VDI"; + else + format = pszExt; + } + rc = openMedium(a, diffparent, DeviceType_HardDisk, + AccessMode_ReadWrite, pParentMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + if (pParentMedium.isNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid parent hard disk reference, avoiding crash"); + MediumState_T state; + CHECK_ERROR(pParentMedium, COMGETTER(State)(&state)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + if (state == MediumState_Inaccessible) + { + CHECK_ERROR(pParentMedium, RefreshState(&state)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + } + } + /* check for filename extension */ + /** @todo use IMediumFormat to cover all extensions generically */ + Utf8Str strName(filename); + if (!RTPathHasSuffix(strName.c_str())) + { + Utf8Str strFormat(format); + if (cmd == CMD_DISK) + { + if (strFormat.compare("vmdk", RTCString::CaseInsensitive) == 0) + strName.append(".vmdk"); + else if (strFormat.compare("vhd", RTCString::CaseInsensitive) == 0) + strName.append(".vhd"); + else + strName.append(".vdi"); + } else if (cmd == CMD_DVD) + strName.append(".iso"); + else if (cmd == CMD_FLOPPY) + strName.append(".img"); + filename = strName.c_str(); + } + + ComPtr<IMedium> pMedium; + if (cmd == CMD_DISK) + rc = createMedium(a, format, filename, DeviceType_HardDisk, + AccessMode_ReadWrite, pMedium); + else if (cmd == CMD_DVD) + rc = createMedium(a, format, filename, DeviceType_DVD, + AccessMode_ReadOnly, pMedium); + else if (cmd == CMD_FLOPPY) + rc = createMedium(a, format, filename, DeviceType_Floppy, + AccessMode_ReadWrite, pMedium); + else + rc = E_INVALIDARG; /* cannot happen but make gcc happy */ + + if (SUCCEEDED(rc) && pMedium) + { + ComPtr<IProgress> pProgress; + com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8); + + for (ULONG i = 0; i < l_variants.size(); ++i) + { + ULONG temp = enmMediumVariant; + temp &= 1<<i; + l_variants [i] = (MediumVariant_T)temp; + } + + if (fBase) + CHECK_ERROR(pMedium, CreateBaseStorage(size, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam())); + else + CHECK_ERROR(pParentMedium, CreateDiffStorage(pMedium, ComSafeArrayAsInParam(l_variants), pProgress.asOutParam())); + if (SUCCEEDED(rc) && pProgress) + { + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR(pProgress, ("Failed to create medium")); + } + } + + if (SUCCEEDED(rc) && pMedium) + { + Bstr uuid; + CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam())); + RTPrintf("Medium created. UUID: %s\n", Utf8Str(uuid).c_str()); + + //CHECK_ERROR(pMedium, Close()); + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aModifyMediumOptions[] = +{ + { "disk", 'H', RTGETOPT_REQ_NOTHING }, + { "dvd", 'D', RTGETOPT_REQ_NOTHING }, + { "floppy", 'L', RTGETOPT_REQ_NOTHING }, + { "--type", 't', RTGETOPT_REQ_STRING }, + { "-type", 't', RTGETOPT_REQ_STRING }, // deprecated + { "settype", 't', RTGETOPT_REQ_STRING }, // deprecated + { "--autoreset", 'z', RTGETOPT_REQ_STRING }, + { "-autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated + { "autoreset", 'z', RTGETOPT_REQ_STRING }, // deprecated + { "--property", 'p', RTGETOPT_REQ_STRING }, + { "--compact", 'c', RTGETOPT_REQ_NOTHING }, + { "-compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated + { "compact", 'c', RTGETOPT_REQ_NOTHING }, // deprecated + { "--resize", 'r', RTGETOPT_REQ_UINT64 }, + { "--resizebyte", 'R', RTGETOPT_REQ_UINT64 }, + { "--move", 'm', RTGETOPT_REQ_STRING }, + { "--setlocation", 'l', RTGETOPT_REQ_STRING }, + { "--description", 'd', RTGETOPT_REQ_STRING } +}; + +RTEXITCODE handleModifyMedium(HandlerArg *a) +{ + HRESULT rc; + int vrc; + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + ComPtr<IMedium> pMedium; + MediumType_T enmMediumType = MediumType_Normal; /* Shut up MSC */ + bool AutoReset = false; + SafeArray<BSTR> mediumPropNames; + SafeArray<BSTR> mediumPropValues; + bool fModifyMediumType = false; + bool fModifyAutoReset = false; + bool fModifyProperties = false; + bool fModifyCompact = false; + bool fModifyResize = false; + bool fModifyResizeMB = false; + bool fMoveMedium = false; + bool fModifyDescription = false; + bool fSetNewLocation = false; + uint64_t cbResize = 0; + const char *pszFilenameOrUuid = NULL; + char *pszNewLocation = NULL; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aModifyMediumOptions, RT_ELEMENTS(g_aModifyMediumOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'H': // disk + if (cmd != CMD_NONE) + return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DISK; + break; + + case 'D': // DVD + if (cmd != CMD_NONE) + return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DVD; + break; + + case 'L': // floppy + if (cmd != CMD_NONE) + return errorSyntax(USAGE_MODIFYMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_FLOPPY; + break; + + case 't': // --type + vrc = parseMediumType(ValueUnion.psz, &enmMediumType); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid medium type '%s'", ValueUnion.psz); + fModifyMediumType = true; + break; + + case 'z': // --autoreset + vrc = parseBool(ValueUnion.psz, &AutoReset); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid autoreset parameter '%s'", ValueUnion.psz); + fModifyAutoReset = true; + break; + + case 'p': // --property + { + /* Parse 'name=value' */ + char *pszProperty = RTStrDup(ValueUnion.psz); + if (pszProperty) + { + char *pDelimiter = strchr(pszProperty, '='); + if (pDelimiter) + { + *pDelimiter = '\0'; + + Bstr bstrName(pszProperty); + Bstr bstrValue(&pDelimiter[1]); + bstrName.detachTo(mediumPropNames.appendedRaw()); + bstrValue.detachTo(mediumPropValues.appendedRaw()); + fModifyProperties = true; + } + else + { + errorArgument("Invalid --property argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + RTStrFree(pszProperty); + } + else + { + RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for medium property '%s'\n", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case 'c': // --compact + fModifyCompact = true; + break; + + case 'r': // --resize + cbResize = ValueUnion.u64 * _1M; + fModifyResize = true; + fModifyResizeMB = true; // do sanity check! + break; + + case 'R': // --resizebyte + cbResize = ValueUnion.u64; + fModifyResize = true; + break; + + case 'm': // --move + /* Get a new location */ + pszNewLocation = RTPathAbsDup(ValueUnion.psz); + fMoveMedium = true; + break; + + case 'l': // --setlocation + /* Get a new location */ + pszNewLocation = RTPathAbsDup(ValueUnion.psz); + fSetNewLocation = true; + break; + + case 'd': // --description + /* Get a new description */ + pszNewLocation = RTStrDup(ValueUnion.psz); + fModifyDescription = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszFilenameOrUuid) + pszFilenameOrUuid = ValueUnion.psz; + else + return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option -%c", c); + else + return errorSyntax(USAGE_MODIFYMEDIUM, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_MODIFYMEDIUM, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_MODIFYMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_MODIFYMEDIUM, "error: %Rrs", c); + } + } + + if (cmd == CMD_NONE) + cmd = CMD_DISK; + + if (!pszFilenameOrUuid) + return errorSyntax(USAGE_MODIFYMEDIUM, "Medium name or UUID required"); + + if (!fModifyMediumType + && !fModifyAutoReset + && !fModifyProperties + && !fModifyCompact + && !fModifyResize + && !fMoveMedium + && !fSetNewLocation + && !fModifyDescription + ) + return errorSyntax(USAGE_MODIFYMEDIUM, "No operation specified"); + + /* Always open the medium if necessary, there is no other way. */ + if (cmd == CMD_DISK) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else + rc = E_INVALIDARG; /* cannot happen but make gcc happy */ + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + if (pMedium.isNull()) + { + RTMsgError("Invalid medium reference, avoiding crash"); + return RTEXITCODE_FAILURE; + } + + if ( fModifyResize + && fModifyResizeMB) + { + // Sanity check + // + // In general users should know what they do but in this case users have no + // alternative to VBoxManage. If happens that one wants to resize the disk + // and uses --resize and does not consider that this parameter expects the + // new medium size in MB not Byte. If the operation is started and then + // aborted by the user, the result is most likely a medium which doesn't + // work anymore. + MediumState_T state; + pMedium->RefreshState(&state); + LONG64 logicalSize; + pMedium->COMGETTER(LogicalSize)(&logicalSize); + if (cbResize > (uint64_t)logicalSize * 1000) + { + RTMsgError("Error: Attempt to resize the medium from %RU64.%RU64 MB to %RU64.%RU64 MB. Use --resizebyte if this is intended!\n", + logicalSize / _1M, (logicalSize % _1M) / (_1M / 10), cbResize / _1M, (cbResize % _1M) / (_1M / 10)); + return RTEXITCODE_FAILURE; + } + } + + if (fModifyMediumType) + { + MediumType_T enmCurrMediumType; + CHECK_ERROR(pMedium, COMGETTER(Type)(&enmCurrMediumType)); + + if (enmCurrMediumType != enmMediumType) + CHECK_ERROR(pMedium, COMSETTER(Type)(enmMediumType)); + } + + if (fModifyAutoReset) + { + CHECK_ERROR(pMedium, COMSETTER(AutoReset)(AutoReset)); + } + + if (fModifyProperties) + { + CHECK_ERROR(pMedium, SetProperties(ComSafeArrayAsInParam(mediumPropNames), ComSafeArrayAsInParam(mediumPropValues))); + } + + if (fModifyCompact) + { + ComPtr<IProgress> pProgress; + CHECK_ERROR(pMedium, Compact(pProgress.asOutParam())); + if (SUCCEEDED(rc)) + rc = showProgress(pProgress); + if (FAILED(rc)) + { + if (rc == E_NOTIMPL) + RTMsgError("Compact medium operation is not implemented!"); + else if (rc == VBOX_E_NOT_SUPPORTED) + RTMsgError("Compact medium operation for this format is not implemented yet!"); + else if (!pProgress.isNull()) + CHECK_PROGRESS_ERROR(pProgress, ("Failed to compact medium")); + else + RTMsgError("Failed to compact medium!"); + } + } + + if (fModifyResize) + { + ComPtr<IProgress> pProgress; + CHECK_ERROR(pMedium, Resize(cbResize, pProgress.asOutParam())); + if (SUCCEEDED(rc)) + rc = showProgress(pProgress); + if (FAILED(rc)) + { + if (!pProgress.isNull()) + CHECK_PROGRESS_ERROR(pProgress, ("Failed to resize medium")); + else if (rc == E_NOTIMPL) + RTMsgError("Resize medium operation is not implemented!"); + else if (rc == VBOX_E_NOT_SUPPORTED) + RTMsgError("Resize medium operation for this format is not implemented yet!"); + else + RTMsgError("Failed to resize medium!"); + } + } + + if (fMoveMedium) + { + do + { + ComPtr<IProgress> pProgress; + Utf8Str strLocation(pszNewLocation); + RTStrFree(pszNewLocation); + CHECK_ERROR(pMedium, MoveTo(Bstr(strLocation).raw(), pProgress.asOutParam())); + + if (SUCCEEDED(rc) && !pProgress.isNull()) + { + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR(pProgress, ("Failed to move medium")); + } + + Bstr uuid; + CHECK_ERROR_BREAK(pMedium, COMGETTER(Id)(uuid.asOutParam())); + + RTPrintf("Move medium with UUID %s finished\n", Utf8Str(uuid).c_str()); + } + while (0); + } + + if (fSetNewLocation) + { + Utf8Str strLocation(pszNewLocation); + RTStrFree(pszNewLocation); + CHECK_ERROR(pMedium, COMSETTER(Location)(Bstr(strLocation).raw())); + + Bstr uuid; + CHECK_ERROR(pMedium, COMGETTER(Id)(uuid.asOutParam())); + RTPrintf("Set new location of medium with UUID %s finished\n", Utf8Str(uuid).c_str()); + } + + if (fModifyDescription) + { + CHECK_ERROR(pMedium, COMSETTER(Description)(Bstr(pszNewLocation).raw())); + + RTPrintf("Medium description has been changed.\n"); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aCloneMediumOptions[] = +{ + { "disk", 'd', RTGETOPT_REQ_NOTHING }, + { "dvd", 'D', RTGETOPT_REQ_NOTHING }, + { "floppy", 'f', RTGETOPT_REQ_NOTHING }, + { "--format", 'o', RTGETOPT_REQ_STRING }, + { "-format", 'o', RTGETOPT_REQ_STRING }, + { "--static", 'F', RTGETOPT_REQ_NOTHING }, + { "-static", 'F', RTGETOPT_REQ_NOTHING }, + { "--existing", 'E', RTGETOPT_REQ_NOTHING }, + { "--variant", 'm', RTGETOPT_REQ_STRING }, + { "-variant", 'm', RTGETOPT_REQ_STRING }, +}; + +RTEXITCODE handleCloneMedium(HandlerArg *a) +{ + HRESULT rc; + int vrc; + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + const char *pszSrc = NULL; + const char *pszDst = NULL; + Bstr format; + MediumVariant_T enmMediumVariant = MediumVariant_Standard; + bool fExisting = false; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneMediumOptions, RT_ELEMENTS(g_aCloneMediumOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'd': // disk + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DISK; + break; + + case 'D': // DVD + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DVD; + break; + + case 'f': // floppy + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLONEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_FLOPPY; + break; + + case 'o': // --format + format = ValueUnion.psz; + break; + + case 'F': // --static + { + unsigned uMediumVariant = (unsigned)enmMediumVariant; + uMediumVariant |= MediumVariant_Fixed; + enmMediumVariant = (MediumVariant_T)uMediumVariant; + break; + } + + case 'E': // --existing + fExisting = true; + break; + + case 'm': // --variant + vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid medium variant '%s'", ValueUnion.psz); + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszSrc) + pszSrc = ValueUnion.psz; + else if (!pszDst) + pszDst = ValueUnion.psz; + else + return errorSyntax(USAGE_CLONEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_GRAPH(c)) + return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: -%c", c); + else + return errorSyntax(USAGE_CLONEMEDIUM, "unhandled option: %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_CLONEMEDIUM, "unknown option: %s", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_CLONEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_CLONEMEDIUM, "error: %Rrs", c); + } + } + + if (cmd == CMD_NONE) + cmd = CMD_DISK; + if (!pszSrc) + return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory UUID or input file parameter missing"); + if (!pszDst) + return errorSyntax(USAGE_CLONEMEDIUM, "Mandatory output file parameter missing"); + if (fExisting && (!format.isEmpty() || enmMediumVariant != MediumVariant_Standard)) + return errorSyntax(USAGE_CLONEMEDIUM, "Specified options which cannot be used with --existing"); + + ComPtr<IMedium> pSrcMedium; + ComPtr<IMedium> pDstMedium; + + if (cmd == CMD_DISK) + rc = openMedium(a, pszSrc, DeviceType_HardDisk, AccessMode_ReadOnly, pSrcMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszSrc, DeviceType_DVD, AccessMode_ReadOnly, pSrcMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszSrc, DeviceType_Floppy, AccessMode_ReadOnly, pSrcMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else + rc = E_INVALIDARG; /* cannot happen but make gcc happy */ + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + do + { + /* open/create destination medium */ + if (fExisting) + { + if (cmd == CMD_DISK) + rc = openMedium(a, pszDst, DeviceType_HardDisk, AccessMode_ReadWrite, pDstMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszDst, DeviceType_DVD, AccessMode_ReadOnly, pDstMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszDst, DeviceType_Floppy, AccessMode_ReadWrite, pDstMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (FAILED(rc)) + break; + + /* Perform accessibility check now. */ + MediumState_T state; + CHECK_ERROR_BREAK(pDstMedium, RefreshState(&state)); + CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Format)(format.asOutParam())); + } + else + { + /* + * In case the format is unspecified check that the source medium supports + * image creation and use the same format for the destination image. + * Use the default image format if it is not supported. + */ + if (format.isEmpty()) + { + ComPtr<IMediumFormat> pMediumFmt; + com::SafeArray<MediumFormatCapabilities_T> l_caps; + CHECK_ERROR_BREAK(pSrcMedium, COMGETTER(MediumFormat)(pMediumFmt.asOutParam())); + CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Capabilities)(ComSafeArrayAsOutParam(l_caps))); + ULONG caps=0; + for (size_t i = 0; i < l_caps.size(); i++) + caps |= l_caps[i]; + if (caps & ( MediumFormatCapabilities_CreateDynamic + | MediumFormatCapabilities_CreateFixed)) + CHECK_ERROR_BREAK(pMediumFmt, COMGETTER(Id)(format.asOutParam())); + } + Utf8Str strFormat(format); + if (cmd == CMD_DISK) + rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_HardDisk, + AccessMode_ReadWrite, pDstMedium); + else if (cmd == CMD_DVD) + rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_DVD, + AccessMode_ReadOnly, pDstMedium); + else if (cmd == CMD_FLOPPY) + rc = createMedium(a, strFormat.c_str(), pszDst, DeviceType_Floppy, + AccessMode_ReadWrite, pDstMedium); + if (FAILED(rc)) + break; + } + + ComPtr<IProgress> pProgress; + com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8); + + for (ULONG i = 0; i < l_variants.size(); ++i) + { + ULONG temp = enmMediumVariant; + temp &= 1<<i; + l_variants [i] = (MediumVariant_T)temp; + } + + CHECK_ERROR_BREAK(pSrcMedium, CloneTo(pDstMedium, ComSafeArrayAsInParam(l_variants), NULL, pProgress.asOutParam())); + + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR_BREAK(pProgress, ("Failed to clone medium")); + + Bstr uuid; + CHECK_ERROR_BREAK(pDstMedium, COMGETTER(Id)(uuid.asOutParam())); + + RTPrintf("Clone medium created in format '%ls'. UUID: %s\n", + format.raw(), Utf8Str(uuid).c_str()); + } + while (0); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aConvertFromRawHardDiskOptions[] = +{ + { "--format", 'o', RTGETOPT_REQ_STRING }, + { "-format", 'o', RTGETOPT_REQ_STRING }, + { "--static", 'F', RTGETOPT_REQ_NOTHING }, + { "-static", 'F', RTGETOPT_REQ_NOTHING }, + { "--variant", 'm', RTGETOPT_REQ_STRING }, + { "-variant", 'm', RTGETOPT_REQ_STRING }, + { "--uuid", 'u', RTGETOPT_REQ_STRING }, +}; + +RTEXITCODE handleConvertFromRaw(HandlerArg *a) +{ + int rc = VINF_SUCCESS; + bool fReadFromStdIn = false; + const char *format = "VDI"; + const char *srcfilename = NULL; + const char *dstfilename = NULL; + const char *filesize = NULL; + unsigned uImageFlags = VD_IMAGE_FLAGS_NONE; + void *pvBuf = NULL; + RTUUID uuid; + PCRTUUID pUuid = NULL; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aConvertFromRawHardDiskOptions, RT_ELEMENTS(g_aConvertFromRawHardDiskOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'u': // --uuid + if (RT_FAILURE(RTUuidFromStr(&uuid, ValueUnion.psz))) + return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid UUID '%s'", ValueUnion.psz); + pUuid = &uuid; + break; + case 'o': // --format + format = ValueUnion.psz; + break; + + case 'm': // --variant + { + MediumVariant_T enmMediumVariant = MediumVariant_Standard; + rc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant); + if (RT_FAILURE(rc)) + return errorArgument("Invalid medium variant '%s'", ValueUnion.psz); + /// @todo cleaner solution than assuming 1:1 mapping? + uImageFlags = (unsigned)enmMediumVariant; + break; + } + case VINF_GETOPT_NOT_OPTION: + if (!srcfilename) + { + srcfilename = ValueUnion.psz; + fReadFromStdIn = !strcmp(srcfilename, "stdin"); + } + else if (!dstfilename) + dstfilename = ValueUnion.psz; + else if (fReadFromStdIn && !filesize) + filesize = ValueUnion.psz; + else + return errorSyntax(USAGE_CONVERTFROMRAW, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + return errorGetOpt(USAGE_CONVERTFROMRAW, c, &ValueUnion); + } + } + + if (!srcfilename || !dstfilename || (fReadFromStdIn && !filesize)) + return errorSyntax(USAGE_CONVERTFROMRAW, "Incorrect number of parameters"); + RTStrmPrintf(g_pStdErr, "Converting from raw image file=\"%s\" to file=\"%s\"...\n", + srcfilename, dstfilename); + + PVDISK pDisk = NULL; + + PVDINTERFACE pVDIfs = NULL; + VDINTERFACEERROR vdInterfaceError; + vdInterfaceError.pfnError = handleVDError; + vdInterfaceError.pfnMessage = NULL; + + rc = VDInterfaceAdd(&vdInterfaceError.Core, "VBoxManage_IError", VDINTERFACETYPE_ERROR, + NULL, sizeof(VDINTERFACEERROR), &pVDIfs); + AssertRC(rc); + + /* open raw image file. */ + RTFILE File; + if (fReadFromStdIn) + rc = RTFileFromNative(&File, RTFILE_NATIVE_STDIN); + else + rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); + if (RT_FAILURE(rc)) + { + RTMsgError("Cannot open file \"%s\": %Rrc", srcfilename, rc); + goto out; + } + + uint64_t cbFile; + /* get image size. */ + if (fReadFromStdIn) + cbFile = RTStrToUInt64(filesize); + else + rc = RTFileGetSize(File, &cbFile); + if (RT_FAILURE(rc)) + { + RTMsgError("Cannot get image size for file \"%s\": %Rrc", srcfilename, rc); + goto out; + } + + RTStrmPrintf(g_pStdErr, "Creating %s image with size %RU64 bytes (%RU64MB)...\n", + (uImageFlags & VD_IMAGE_FLAGS_FIXED) ? "fixed" : "dynamic", cbFile, (cbFile + _1M - 1) / _1M); + char pszComment[256]; + RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", srcfilename); + rc = VDCreate(pVDIfs, VDTYPE_HDD, &pDisk); + if (RT_FAILURE(rc)) + { + RTMsgError("Cannot create the virtual disk container: %Rrc", rc); + goto out; + } + + Assert(RT_MIN(cbFile / 512 / 16 / 63, 16383) - + (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383) == 0); + VDGEOMETRY PCHS, LCHS; + PCHS.cCylinders = (unsigned int)RT_MIN(cbFile / 512 / 16 / 63, 16383); + PCHS.cHeads = 16; + PCHS.cSectors = 63; + LCHS.cCylinders = 0; + LCHS.cHeads = 0; + LCHS.cSectors = 0; + rc = VDCreateBase(pDisk, format, dstfilename, cbFile, + uImageFlags, pszComment, &PCHS, &LCHS, pUuid, + VD_OPEN_FLAGS_NORMAL, NULL, NULL); + if (RT_FAILURE(rc)) + { + RTMsgError("Cannot create the disk image \"%s\": %Rrc", dstfilename, rc); + goto out; + } + + size_t cbBuffer; + cbBuffer = _1M; + pvBuf = RTMemAlloc(cbBuffer); + if (!pvBuf) + { + rc = VERR_NO_MEMORY; + RTMsgError("Out of memory allocating buffers for image \"%s\": %Rrc", dstfilename, rc); + goto out; + } + + uint64_t offFile; + offFile = 0; + while (offFile < cbFile) + { + size_t cbRead; + size_t cbToRead; + cbRead = 0; + cbToRead = cbFile - offFile >= (uint64_t)cbBuffer ? + cbBuffer : (size_t)(cbFile - offFile); + rc = RTFileRead(File, pvBuf, cbToRead, &cbRead); + if (RT_FAILURE(rc) || !cbRead) + break; + rc = VDWrite(pDisk, offFile, pvBuf, cbRead); + if (RT_FAILURE(rc)) + { + RTMsgError("Failed to write to disk image \"%s\": %Rrc", dstfilename, rc); + goto out; + } + offFile += cbRead; + } + +out: + if (pvBuf) + RTMemFree(pvBuf); + if (pDisk) + VDClose(pDisk, RT_FAILURE(rc)); + if (File != NIL_RTFILE) + RTFileClose(File); + + return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +HRESULT showMediumInfo(const ComPtr<IVirtualBox> &pVirtualBox, + const ComPtr<IMedium> &pMedium, + const char *pszParentUUID, + bool fOptLong) +{ + HRESULT rc = S_OK; + do + { + Bstr uuid; + pMedium->COMGETTER(Id)(uuid.asOutParam()); + RTPrintf("UUID: %ls\n", uuid.raw()); + if (pszParentUUID) + RTPrintf("Parent UUID: %s\n", pszParentUUID); + + /* check for accessibility */ + MediumState_T enmState; + CHECK_ERROR_BREAK(pMedium, RefreshState(&enmState)); + const char *pszState = "unknown"; + switch (enmState) + { + case MediumState_NotCreated: + pszState = "not created"; + break; + case MediumState_Created: + pszState = "created"; + break; + case MediumState_LockedRead: + pszState = "locked read"; + break; + case MediumState_LockedWrite: + pszState = "locked write"; + break; + case MediumState_Inaccessible: + pszState = "inaccessible"; + break; + case MediumState_Creating: + pszState = "creating"; + break; + case MediumState_Deleting: + pszState = "deleting"; + break; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case MediumState_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + RTPrintf("State: %s\n", pszState); + + if (fOptLong && enmState == MediumState_Inaccessible) + { + Bstr err; + CHECK_ERROR_BREAK(pMedium, COMGETTER(LastAccessError)(err.asOutParam())); + RTPrintf("Access Error: %ls\n", err.raw()); + } + + if (fOptLong) + { + Bstr description; + pMedium->COMGETTER(Description)(description.asOutParam()); + if (!description.isEmpty()) + RTPrintf("Description: %ls\n", description.raw()); + } + + MediumType_T type; + pMedium->COMGETTER(Type)(&type); + const char *typeStr = "unknown"; + switch (type) + { + case MediumType_Normal: + if (pszParentUUID && Guid(pszParentUUID).isValid()) + typeStr = "normal (differencing)"; + else + typeStr = "normal (base)"; + break; + case MediumType_Immutable: + typeStr = "immutable"; + break; + case MediumType_Writethrough: + typeStr = "writethrough"; + break; + case MediumType_Shareable: + typeStr = "shareable"; + break; + case MediumType_Readonly: + typeStr = "readonly"; + break; + case MediumType_MultiAttach: + typeStr = "multiattach"; + break; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case MediumType_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + RTPrintf("Type: %s\n", typeStr); + + /* print out information specific for differencing media */ + if (fOptLong && pszParentUUID && Guid(pszParentUUID).isValid()) + { + BOOL autoReset = FALSE; + pMedium->COMGETTER(AutoReset)(&autoReset); + RTPrintf("Auto-Reset: %s\n", autoReset ? "on" : "off"); + } + + Bstr loc; + pMedium->COMGETTER(Location)(loc.asOutParam()); + RTPrintf("Location: %ls\n", loc.raw()); + + Bstr format; + pMedium->COMGETTER(Format)(format.asOutParam()); + RTPrintf("Storage format: %ls\n", format.raw()); + + if (fOptLong) + { + com::SafeArray<MediumVariant_T> safeArray_variant; + + pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(safeArray_variant)); + ULONG variant=0; + for (size_t i = 0; i < safeArray_variant.size(); i++) + variant |= safeArray_variant[i]; + + const char *variantStr = "unknown"; + switch (variant & ~(MediumVariant_Fixed | MediumVariant_Diff)) + { + case MediumVariant_VmdkSplit2G: + variantStr = "split2G"; + break; + case MediumVariant_VmdkStreamOptimized: + variantStr = "streamOptimized"; + break; + case MediumVariant_VmdkESX: + variantStr = "ESX"; + break; + case MediumVariant_Standard: + variantStr = "default"; + break; + } + const char *variantTypeStr = "dynamic"; + if (variant & MediumVariant_Fixed) + variantTypeStr = "fixed"; + else if (variant & MediumVariant_Diff) + variantTypeStr = "differencing"; + RTPrintf("Format variant: %s %s\n", variantTypeStr, variantStr); + } + + LONG64 logicalSize; + pMedium->COMGETTER(LogicalSize)(&logicalSize); + RTPrintf("Capacity: %lld MBytes\n", logicalSize >> 20); + if (fOptLong) + { + LONG64 actualSize; + pMedium->COMGETTER(Size)(&actualSize); + RTPrintf("Size on disk: %lld MBytes\n", actualSize >> 20); + } + + Bstr strCipher; + Bstr strPasswordId; + HRESULT rc2 = pMedium->GetEncryptionSettings(strCipher.asOutParam(), strPasswordId.asOutParam()); + if (SUCCEEDED(rc2)) + { + RTPrintf("Encryption: enabled\n"); + if (fOptLong) + { + RTPrintf("Cipher: %ls\n", strCipher.raw()); + RTPrintf("Password ID: %ls\n", strPasswordId.raw()); + } + } + else + RTPrintf("Encryption: disabled\n"); + + if (fOptLong) + { + com::SafeArray<BSTR> names; + com::SafeArray<BSTR> values; + pMedium->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values)); + size_t cNames = names.size(); + size_t cValues = values.size(); + bool fFirst = true; + for (size_t i = 0; i < cNames; i++) + { + Bstr value; + if (i < cValues) + value = values[i]; + RTPrintf("%s%ls=%ls\n", + fFirst ? "Property: " : " ", + names[i], value.raw()); + fFirst = false; + } + } + + if (fOptLong) + { + bool fFirst = true; + com::SafeArray<BSTR> machineIds; + pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds)); + for (size_t i = 0; i < machineIds.size(); i++) + { + ComPtr<IMachine> pMachine; + CHECK_ERROR(pVirtualBox, FindMachine(machineIds[i], pMachine.asOutParam())); + if (pMachine) + { + Bstr name; + pMachine->COMGETTER(Name)(name.asOutParam()); + pMachine->COMGETTER(Id)(uuid.asOutParam()); + RTPrintf("%s%ls (UUID: %ls)", + fFirst ? "In use by VMs: " : " ", + name.raw(), machineIds[i]); + fFirst = false; + com::SafeArray<BSTR> snapshotIds; + pMedium->GetSnapshotIds(machineIds[i], + ComSafeArrayAsOutParam(snapshotIds)); + for (size_t j = 0; j < snapshotIds.size(); j++) + { + ComPtr<ISnapshot> pSnapshot; + pMachine->FindSnapshot(snapshotIds[j], pSnapshot.asOutParam()); + if (pSnapshot) + { + Bstr snapshotName; + pSnapshot->COMGETTER(Name)(snapshotName.asOutParam()); + RTPrintf(" [%ls (UUID: %ls)]", snapshotName.raw(), snapshotIds[j]); + } + } + RTPrintf("\n"); + } + } + } + + if (fOptLong) + { + com::SafeIfaceArray<IMedium> children; + pMedium->COMGETTER(Children)(ComSafeArrayAsOutParam(children)); + bool fFirst = true; + for (size_t i = 0; i < children.size(); i++) + { + ComPtr<IMedium> pChild(children[i]); + if (pChild) + { + Bstr childUUID; + pChild->COMGETTER(Id)(childUUID.asOutParam()); + RTPrintf("%s%ls\n", + fFirst ? "Child UUIDs: " : " ", + childUUID.raw()); + fFirst = false; + } + } + } + } + while (0); + + return rc; +} + +static const RTGETOPTDEF g_aShowMediumInfoOptions[] = +{ + { "disk", 'd', RTGETOPT_REQ_NOTHING }, + { "dvd", 'D', RTGETOPT_REQ_NOTHING }, + { "floppy", 'f', RTGETOPT_REQ_NOTHING }, +}; + +RTEXITCODE handleShowMediumInfo(HandlerArg *a) +{ + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + const char *pszFilenameOrUuid = NULL; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aShowMediumInfoOptions, RT_ELEMENTS(g_aShowMediumInfoOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'd': // disk + if (cmd != CMD_NONE) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DISK; + break; + + case 'D': // DVD + if (cmd != CMD_NONE) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DVD; + break; + + case 'f': // floppy + if (cmd != CMD_NONE) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_FLOPPY; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszFilenameOrUuid) + pszFilenameOrUuid = ValueUnion.psz; + else + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option -%c", c); + else + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_SHOWMEDIUMINFO, "error: %Rrs", c); + } + } + + if (cmd == CMD_NONE) + cmd = CMD_DISK; + + /* check for required options */ + if (!pszFilenameOrUuid) + return errorSyntax(USAGE_SHOWMEDIUMINFO, "Medium name or UUID required"); + + HRESULT rc = S_OK; /* Prevents warning. */ + + ComPtr<IMedium> pMedium; + if (cmd == CMD_DISK) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + Utf8Str strParentUUID("base"); + ComPtr<IMedium> pParent; + pMedium->COMGETTER(Parent)(pParent.asOutParam()); + if (!pParent.isNull()) + { + Bstr bstrParentUUID; + pParent->COMGETTER(Id)(bstrParentUUID.asOutParam()); + strParentUUID = bstrParentUUID; + } + + rc = showMediumInfo(a->virtualBox, pMedium, strParentUUID.c_str(), true); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aCloseMediumOptions[] = +{ + { "disk", 'd', RTGETOPT_REQ_NOTHING }, + { "dvd", 'D', RTGETOPT_REQ_NOTHING }, + { "floppy", 'f', RTGETOPT_REQ_NOTHING }, + { "--delete", 'r', RTGETOPT_REQ_NOTHING }, +}; + +RTEXITCODE handleCloseMedium(HandlerArg *a) +{ + HRESULT rc = S_OK; + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + const char *pszFilenameOrUuid = NULL; + bool fDelete = false; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aCloseMediumOptions, RT_ELEMENTS(g_aCloseMediumOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'd': // disk + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DISK; + break; + + case 'D': // DVD + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_DVD; + break; + + case 'f': // floppy + if (cmd != CMD_NONE) + return errorSyntax(USAGE_CLOSEMEDIUM, "Only one command can be specified: '%s'", ValueUnion.psz); + cmd = CMD_FLOPPY; + break; + + case 'r': // --delete + fDelete = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszFilenameOrUuid) + pszFilenameOrUuid = ValueUnion.psz; + else + return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option -%c", c); + else + return errorSyntax(USAGE_CLOSEMEDIUM, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_CLOSEMEDIUM, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_CLOSEMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_CLOSEMEDIUM, "error: %Rrs", c); + } + } + + /* check for required options */ + if (cmd == CMD_NONE) + cmd = CMD_DISK; + if (!pszFilenameOrUuid) + return errorSyntax(USAGE_CLOSEMEDIUM, "Medium name or UUID required"); + + ComPtr<IMedium> pMedium; + if (cmd == CMD_DISK) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + + if (SUCCEEDED(rc) && pMedium) + { + if (fDelete) + { + ComPtr<IProgress> pProgress; + CHECK_ERROR(pMedium, DeleteStorage(pProgress.asOutParam())); + if (SUCCEEDED(rc)) + { + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR(pProgress, ("Failed to delete medium")); + } + else + RTMsgError("Failed to delete medium. Error code %Rrc", rc); + } + CHECK_ERROR(pMedium, Close()); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleMediumProperty(HandlerArg *a) +{ + HRESULT rc = S_OK; + const char *pszCmd = NULL; + enum { + CMD_NONE, + CMD_DISK, + CMD_DVD, + CMD_FLOPPY + } cmd = CMD_NONE; + const char *pszAction = NULL; + const char *pszFilenameOrUuid = NULL; + const char *pszProperty = NULL; + ComPtr<IMedium> pMedium; + + pszCmd = (a->argc > 0) ? a->argv[0] : ""; + if ( !RTStrICmp(pszCmd, "disk") + || !RTStrICmp(pszCmd, "dvd") + || !RTStrICmp(pszCmd, "floppy")) + { + if (!RTStrICmp(pszCmd, "disk")) + cmd = CMD_DISK; + else if (!RTStrICmp(pszCmd, "dvd")) + cmd = CMD_DVD; + else if (!RTStrICmp(pszCmd, "floppy")) + cmd = CMD_FLOPPY; + else + { + AssertMsgFailed(("unexpected parameter %s\n", pszCmd)); + cmd = CMD_DISK; + } + a->argv++; + a->argc--; + } + else + { + pszCmd = NULL; + cmd = CMD_DISK; + } + + if (a->argc == 0) + return errorSyntax(USAGE_MEDIUMPROPERTY, "Missing action"); + + pszAction = a->argv[0]; + if ( RTStrICmp(pszAction, "set") + && RTStrICmp(pszAction, "get") + && RTStrICmp(pszAction, "delete")) + return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid action given: %s", pszAction); + + if ( ( !RTStrICmp(pszAction, "set") + && a->argc != 4) + || ( RTStrICmp(pszAction, "set") + && a->argc != 3)) + return errorSyntax(USAGE_MEDIUMPROPERTY, "Invalid number of arguments given for action: %s", pszAction); + + pszFilenameOrUuid = a->argv[1]; + pszProperty = a->argv[2]; + + if (cmd == CMD_DISK) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_DVD) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_DVD, + AccessMode_ReadOnly, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + else if (cmd == CMD_FLOPPY) + rc = openMedium(a, pszFilenameOrUuid, DeviceType_Floppy, + AccessMode_ReadWrite, pMedium, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (SUCCEEDED(rc) && !pMedium.isNull()) + { + if (!RTStrICmp(pszAction, "set")) + { + const char *pszValue = a->argv[3]; + CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr(pszValue).raw())); + } + else if (!RTStrICmp(pszAction, "get")) + { + Bstr strVal; + CHECK_ERROR(pMedium, GetProperty(Bstr(pszProperty).raw(), strVal.asOutParam())); + if (SUCCEEDED(rc)) + RTPrintf("%s=%ls\n", pszProperty, strVal.raw()); + } + else if (!RTStrICmp(pszAction, "delete")) + { + CHECK_ERROR(pMedium, SetProperty(Bstr(pszProperty).raw(), Bstr().raw())); + /** @todo */ + } + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aEncryptMediumOptions[] = +{ + { "--newpassword", 'n', RTGETOPT_REQ_STRING }, + { "--oldpassword", 'o', RTGETOPT_REQ_STRING }, + { "--cipher", 'c', RTGETOPT_REQ_STRING }, + { "--newpasswordid", 'i', RTGETOPT_REQ_STRING } +}; + +RTEXITCODE handleEncryptMedium(HandlerArg *a) +{ + HRESULT rc; + ComPtr<IMedium> hardDisk; + const char *pszPasswordNew = NULL; + const char *pszPasswordOld = NULL; + const char *pszCipher = NULL; + const char *pszFilenameOrUuid = NULL; + const char *pszNewPasswordId = NULL; + Utf8Str strPasswordNew; + Utf8Str strPasswordOld; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aEncryptMediumOptions, RT_ELEMENTS(g_aEncryptMediumOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'n': // --newpassword + pszPasswordNew = ValueUnion.psz; + break; + + case 'o': // --oldpassword + pszPasswordOld = ValueUnion.psz; + break; + + case 'c': // --cipher + pszCipher = ValueUnion.psz; + break; + + case 'i': // --newpasswordid + pszNewPasswordId = ValueUnion.psz; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszFilenameOrUuid) + pszFilenameOrUuid = ValueUnion.psz; + else + return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option -%c", c); + else + return errorSyntax(USAGE_ENCRYPTMEDIUM, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_ENCRYPTMEDIUM, "error: %Rrs", c); + } + } + + if (!pszFilenameOrUuid) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "Disk name or UUID required"); + + if (!pszPasswordNew && !pszPasswordOld) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "No password specified"); + + if ( (pszPasswordNew && !pszNewPasswordId) + || (!pszPasswordNew && pszNewPasswordId)) + return errorSyntax(USAGE_ENCRYPTMEDIUM, "A new password must always have a valid identifier set at the same time"); + + if (pszPasswordNew) + { + if (!RTStrCmp(pszPasswordNew, "-")) + { + /* Get password from console. */ + RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordNew, "Enter new password:"); + if (rcExit == RTEXITCODE_FAILURE) + return rcExit; + } + else + { + RTEXITCODE rcExit = readPasswordFile(pszPasswordNew, &strPasswordNew); + if (rcExit == RTEXITCODE_FAILURE) + { + RTMsgError("Failed to read new password from file"); + return rcExit; + } + } + } + + if (pszPasswordOld) + { + if (!RTStrCmp(pszPasswordOld, "-")) + { + /* Get password from console. */ + RTEXITCODE rcExit = readPasswordFromConsole(&strPasswordOld, "Enter old password:"); + if (rcExit == RTEXITCODE_FAILURE) + return rcExit; + } + else + { + RTEXITCODE rcExit = readPasswordFile(pszPasswordOld, &strPasswordOld); + if (rcExit == RTEXITCODE_FAILURE) + { + RTMsgError("Failed to read old password from file"); + return rcExit; + } + } + } + + /* Always open the medium if necessary, there is no other way. */ + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadWrite, hardDisk, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + if (hardDisk.isNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash"); + + ComPtr<IProgress> progress; + CHECK_ERROR(hardDisk, ChangeEncryption(Bstr(strPasswordOld).raw(), Bstr(pszCipher).raw(), + Bstr(strPasswordNew).raw(), Bstr(pszNewPasswordId).raw(), + progress.asOutParam())); + if (SUCCEEDED(rc)) + rc = showProgress(progress); + if (FAILED(rc)) + { + if (rc == E_NOTIMPL) + RTMsgError("Encrypt hard disk operation is not implemented!"); + else if (rc == VBOX_E_NOT_SUPPORTED) + RTMsgError("Encrypt hard disk operation for this cipher is not implemented yet!"); + else if (!progress.isNull()) + CHECK_PROGRESS_ERROR(progress, ("Failed to encrypt hard disk")); + else + RTMsgError("Failed to encrypt hard disk!"); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleCheckMediumPassword(HandlerArg *a) +{ + HRESULT rc; + ComPtr<IMedium> hardDisk; + const char *pszFilenameOrUuid = NULL; + Utf8Str strPassword; + + if (a->argc != 2) + return errorSyntax(USAGE_MEDIUMENCCHKPWD, "Invalid number of arguments: %d", a->argc); + + pszFilenameOrUuid = a->argv[0]; + + if (!RTStrCmp(a->argv[1], "-")) + { + /* Get password from console. */ + RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter password:"); + if (rcExit == RTEXITCODE_FAILURE) + return rcExit; + } + else + { + RTEXITCODE rcExit = readPasswordFile(a->argv[1], &strPassword); + if (rcExit == RTEXITCODE_FAILURE) + { + RTMsgError("Failed to read password from file"); + return rcExit; + } + } + + /* Always open the medium if necessary, there is no other way. */ + rc = openMedium(a, pszFilenameOrUuid, DeviceType_HardDisk, + AccessMode_ReadWrite, hardDisk, + false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + if (hardDisk.isNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Invalid hard disk reference, avoiding crash"); + + CHECK_ERROR(hardDisk, CheckEncryptionPassword(Bstr(strPassword).raw())); + if (SUCCEEDED(rc)) + RTPrintf("The given password is correct\n"); + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +/********************************************************************************************************************************* +* The mediumio command * +*********************************************************************************************************************************/ + +/** + * Common MediumIO options. + */ +typedef struct MEDIUMIOCOMMONOPT +{ + const char *pszFilenameOrUuid; + DeviceType_T enmDeviceType; + const char *pszPasswordFile; +} MEDIUMIOCOMMONOPT; +typedef MEDIUMIOCOMMONOPT *PMEDIUMIOCOMMONOPT; +typedef MEDIUMIOCOMMONOPT const *PCMEDIUMIOCOMMONOPT; + +/* For RTGETOPTDEF array initializer. */ +#define MEDIUMIOCOMMONOPT_DEFS() \ + { "--disk", 'd', RTGETOPT_REQ_STRING }, \ + { "--harddisk", 'd', RTGETOPT_REQ_STRING }, \ + { "disk", 'd', RTGETOPT_REQ_STRING }, \ + { "harddisk", 'd', RTGETOPT_REQ_STRING }, \ + { "--dvd", 'D', RTGETOPT_REQ_STRING }, \ + { "--iso", 'D', RTGETOPT_REQ_STRING }, \ + { "dvd", 'D', RTGETOPT_REQ_STRING }, \ + { "iso", 'D', RTGETOPT_REQ_STRING }, \ + { "--floppy", 'f', RTGETOPT_REQ_STRING }, \ + { "floppy", 'f', RTGETOPT_REQ_STRING }, \ + { "--password-file", 'P', RTGETOPT_REQ_STRING } + +/* For option switch. */ +#define MEDIUMIOCOMMONOPT_CASES(a_pCommonOpts) \ + case 'd': \ + (a_pCommonOpts)->enmDeviceType = DeviceType_HardDisk; \ + (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \ + break; \ + case 'D': \ + (a_pCommonOpts)->enmDeviceType = DeviceType_DVD; \ + (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \ + break; \ + case 'f': \ + (a_pCommonOpts)->enmDeviceType = DeviceType_Floppy; \ + (a_pCommonOpts)->pszFilenameOrUuid = ValueUnion.psz; \ + break; \ + case 'P': \ + (a_pCommonOpts)->pszPasswordFile = ValueUnion.psz; \ + break + + +/** + * Worker for mediumio operations that returns a IMediumIO for the specified + * medium. + * + * @returns Exit code. + * @param pHandler The handler state structure (for IVirtualBox). + * @param pCommonOpts Common mediumio options. + * @param fWritable Whether to open writable (true) or read only + * (false). + * @param rPtrMediumIO Where to return the IMediumIO pointer. + * @param pcbMedium Where to return the meidum size. Optional. + */ +static RTEXITCODE mediumIOOpenMediumForIO(HandlerArg *pHandler, PCMEDIUMIOCOMMONOPT pCommonOpts, bool fWritable, + ComPtr<IMediumIO> &rPtrMediumIO, uint64_t *pcbMedium = NULL) +{ + /* Clear returns. */ + if (pcbMedium) + *pcbMedium = 0; + rPtrMediumIO.setNull(); + + /* + * Make sure a medium was specified already. + */ + if (pCommonOpts->enmDeviceType == DeviceType_Null) + return errorSyntax("No medium specified!"); + + /* + * Read the password. + */ + Bstr bstrPassword; + if (pCommonOpts->pszPasswordFile) + { + Utf8Str strPassword; + RTEXITCODE rcExit; + if (pCommonOpts->pszPasswordFile[0] == '-' && pCommonOpts->pszPasswordFile[1] == '\0') + rcExit = readPasswordFromConsole(&strPassword, "Enter encryption password:"); + else + rcExit = readPasswordFile(pCommonOpts->pszPasswordFile, &strPassword); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + bstrPassword = strPassword; + strPassword.assign(strPassword.length(), '*'); + } + + /* + * Open the medium and then get I/O access to it. + */ + ComPtr<IMedium> ptrMedium; + HRESULT hrc = openMedium(pHandler, pCommonOpts->pszFilenameOrUuid, pCommonOpts->enmDeviceType, + fWritable ? AccessMode_ReadWrite : AccessMode_ReadOnly, + ptrMedium, false /* fForceNewUuidOnOpen */, false /* fSilent */); + if (SUCCEEDED(hrc)) + { + CHECK_ERROR2I_STMT(ptrMedium, OpenForIO(fWritable, bstrPassword.raw(), rPtrMediumIO.asOutParam()), hrc = hrcCheck); + + /* + * If the size is requested get it after we've opened it. + */ + if (pcbMedium && SUCCEEDED(hrc)) + { + LONG64 cbLogical = 0; + CHECK_ERROR2I_STMT(ptrMedium, COMGETTER(LogicalSize)(&cbLogical), hrc = hrcCheck); + *pcbMedium = cbLogical; + if (!SUCCEEDED(hrc)) + rPtrMediumIO.setNull(); + } + } + + if (bstrPassword.isNotEmpty()) + memset(bstrPassword.mutableRaw(), '*', bstrPassword.length() * sizeof(RTUTF16)); + return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +/** + * mediumio formatfat + */ +static RTEXITCODE handleMediumIOFormatFat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts) +{ + /* + * Parse the options. + */ + bool fQuick = false; + static const RTGETOPTDEF s_aOptions[] = + { + MEDIUMIOCOMMONOPT_DEFS(), + { "--quick", 'q', RTGETOPT_REQ_NOTHING }, + }; + + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0); + AssertRC(rc); + RTGETOPTUNION ValueUnion; + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + MEDIUMIOCOMMONOPT_CASES(pCommonOpts); + + case 'q': + fQuick = true; + break; + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + /* + * Open the medium for I/O and format it. + */ + ComPtr<IMediumIO> ptrMediumIO; + RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, true /*fWritable*/, ptrMediumIO); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + CHECK_ERROR2I_RET(ptrMediumIO, FormatFAT(fQuick), RTEXITCODE_FAILURE); + return RTEXITCODE_SUCCESS; +} + +/** + * mediumio cat + */ +static RTEXITCODE handleMediumIOCat(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts) +{ + /* + * Parse the options. + */ + static const RTGETOPTDEF s_aOptions[] = + { + MEDIUMIOCOMMONOPT_DEFS(), + { "--hex", 'H', RTGETOPT_REQ_NOTHING }, + { "--offset", 'o', RTGETOPT_REQ_UINT64 }, + { "--output", 'O', RTGETOPT_REQ_STRING }, + { "--size", 's', RTGETOPT_REQ_UINT64 }, + }; + bool fHex = false; + uint64_t off = 0; + const char *pszOutput = NULL; + uint64_t cb = UINT64_MAX; + + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0); + AssertRC(rc); + RTGETOPTUNION ValueUnion; + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + MEDIUMIOCOMMONOPT_CASES(pCommonOpts); + + case 'H': + fHex = true; + break; + + case 'o': + off = ValueUnion.u64; + break; + + case 'O': + pszOutput = ValueUnion.psz; + break; + + case 's': + cb = ValueUnion.u64; + break; + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + /* + * Open the medium for I/O. + */ + ComPtr<IMediumIO> ptrMediumIO; + uint64_t cbMedium; + RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /*fWritable*/, ptrMediumIO, &cbMedium); + if (rcExit == RTEXITCODE_SUCCESS) + { + /* + * Do we have an output file or do we write to stdout? + */ + PRTSTREAM pOut = NULL; + if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0')) + { + int vrc = RTStrmOpen(pszOutput, fHex ? "wt" : "wb", &pOut); + if (RT_FAILURE(vrc)) + rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc); + } + else + { + pOut = g_pStdOut; + if (!fHex) + RTStrmSetMode(pOut, true, -1); + } + + if (rcExit == RTEXITCODE_SUCCESS) + { + /* + * Adjust 'cb' now that we've got the medium size. + */ + if (off >= cbMedium) + { + RTMsgWarning("Specified offset (%#RX64) is beyond the end of the medium (%#RX64)", off, cbMedium); + cb = 0; + } + else if ( cb > cbMedium + || cb + off > cbMedium) + cb = cbMedium - off; + + /* + * Hex dump preps. (The duplication detection is making ASSUMPTIONS about + * all the reads being a multiple of cchWidth, except for the final one.) + */ + char abHexBuf[16] = { 0 }; + size_t cbHexBuf = 0; + unsigned const cchWidth = RT_ELEMENTS(abHexBuf); + uint64_t const offEndDupCheck = cb - cchWidth; + uint64_t cDuplicates = 0; + + /* + * Do the reading. + */ + while (cb > 0) + { + char szLine[32 + cchWidth * 4 + 32]; + + /* Do the reading. */ + uint32_t const cbToRead = (uint32_t)RT_MIN(cb, _128K); + SafeArray<BYTE> SafeArrayBuf; + HRESULT hrc = ptrMediumIO->Read(off, cbToRead, ComSafeArrayAsOutParam(SafeArrayBuf)); + if (FAILED(hrc)) + { + RTStrPrintf(szLine, sizeof(szLine), "Read(%zu bytes at %#RX64)", cbToRead, off); + com::GlueHandleComError(ptrMediumIO, szLine, hrc, __FILE__, __LINE__); + break; + } + + /* Output the data. */ + size_t const cbReturned = SafeArrayBuf.size(); + if (cbReturned) + { + BYTE const *pbBuf = SafeArrayBuf.raw(); + int vrc = VINF_SUCCESS; + if (!fHex) + vrc = RTStrmWrite(pOut, pbBuf, cbReturned); + else + { + /* hexdump -C */ + uint64_t offHex = off; + uint64_t const offHexEnd = off + cbReturned; + while (offHex < offHexEnd) + { + if ( offHex >= offEndDupCheck + || cbHexBuf == 0 + || memcmp(pbBuf, abHexBuf, cchWidth) != 0 + || ( cDuplicates == 0 + && ( offHex + cchWidth >= offEndDupCheck + || memcmp(pbBuf + cchWidth, pbBuf, cchWidth) != 0)) ) + { + if (cDuplicates > 0) + { + RTStrmPrintf(pOut, "********** <ditto x %RU64>\n", cDuplicates); + cDuplicates = 0; + } + + size_t cch = RTStrPrintf(szLine, sizeof(szLine), "%012RX64:", offHex); + unsigned i; + for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++) + { + static const char s_szHexDigits[17] = "0123456789abcdef"; + szLine[cch++] = (i & 7) || i == 0 ? ' ' : '-'; + uint8_t const u8 = pbBuf[i]; + szLine[cch++] = s_szHexDigits[u8 >> 4]; + szLine[cch++] = s_szHexDigits[u8 & 0xf]; + } + while (i++ < cchWidth) + { + szLine[cch++] = ' '; + szLine[cch++] = ' '; + szLine[cch++] = ' '; + } + szLine[cch++] = ' '; + + for (i = 0; i < cchWidth && offHex + i < offHexEnd; i++) + { + uint8_t const u8 = pbBuf[i]; + szLine[cch++] = u8 < 127 && u8 >= 32 ? u8 : '.'; + } + szLine[cch++] = '\n'; + szLine[cch] = '\0'; + + vrc = RTStrmWrite(pOut, szLine, cch); + if (RT_FAILURE(vrc)) + break; + + + /* copy bytes over to the duplication detection buffer. */ + cbHexBuf = (size_t)RT_MIN(cchWidth, offHexEnd - offHex); + memcpy(abHexBuf, pbBuf, cbHexBuf); + } + else + cDuplicates++; + + /* Advance to next line. */ + pbBuf += cchWidth; + offHex += cchWidth; + } + } + if (RT_FAILURE(vrc)) + { + rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc); + break; + } + } + + /* Advance. */ + if (cbReturned != cbToRead) + { + rcExit = RTMsgErrorExitFailure("Expected read() at offset %RU64 (%#RX64) to return %#zx bytes, only got %#zx!\n", + off, off, cbReturned, cbToRead); + break; + } + off += cbReturned; + cb -= cbReturned; + } + + /* + * Close output. + */ + if (pOut != g_pStdOut) + { + int vrc = RTStrmClose(pOut); + if (RT_FAILURE(vrc)) + rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc); + } + else if (!fHex) + RTStrmSetMode(pOut, false, -1); + } + } + return rcExit; +} + +/** + * mediumio stream + */ +static RTEXITCODE handleMediumIOStream(HandlerArg *a, int iFirst, PMEDIUMIOCOMMONOPT pCommonOpts) +{ + /* + * Parse the options. + */ + static const RTGETOPTDEF s_aOptions[] = + { + MEDIUMIOCOMMONOPT_DEFS(), + { "--output", 'O', RTGETOPT_REQ_STRING }, + { "--format", 'F', RTGETOPT_REQ_STRING }, + { "--variant", 'v', RTGETOPT_REQ_STRING } + }; + const char *pszOutput = NULL; + MediumVariant_T enmMediumVariant = MediumVariant_Standard; + Bstr strFormat; + + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), iFirst, 0); + AssertRC(rc); + RTGETOPTUNION ValueUnion; + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + MEDIUMIOCOMMONOPT_CASES(pCommonOpts); + + case 'O': + pszOutput = ValueUnion.psz; + break; + case 'F': + strFormat = ValueUnion.psz; + break; + case 'v': // --variant + { + int vrc = parseMediumVariant(ValueUnion.psz, &enmMediumVariant); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid medium variant '%s'", ValueUnion.psz); + break; + } + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + + /* + * Open the medium for I/O. + */ + ComPtr<IMediumIO> ptrMediumIO; + uint64_t cbMedium; + RTEXITCODE rcExit = mediumIOOpenMediumForIO(a, pCommonOpts, false /*fWritable*/, ptrMediumIO, &cbMedium); + if (rcExit == RTEXITCODE_SUCCESS) + { + /* + * Do we have an output file or do we write to stdout? + */ + PRTSTREAM pOut = NULL; + if (pszOutput && (pszOutput[0] != '-' || pszOutput[1] != '\0')) + { + int vrc = RTStrmOpen(pszOutput, "wb", &pOut); + if (RT_FAILURE(vrc)) + rcExit = RTMsgErrorExitFailure("Error opening '%s' for writing: %Rrc", pszOutput, vrc); + } + else + { + pOut = g_pStdOut; + RTStrmSetMode(pOut, true, -1); + } + + if (rcExit == RTEXITCODE_SUCCESS) + { + ComPtr<IDataStream> ptrDataStream; + ComPtr<IProgress> ptrProgress; + + com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8); + + for (ULONG i = 0; i < l_variants.size(); ++i) + { + ULONG temp = enmMediumVariant; + temp &= 1<<i; + l_variants [i] = (MediumVariant_T)temp; + } + + HRESULT hrc = ptrMediumIO->ConvertToStream(strFormat.raw(), ComSafeArrayAsInParam(l_variants), 10 * _1M, ptrDataStream.asOutParam(), ptrProgress.asOutParam()); + if (hrc == S_OK) + { + /* Read until we reached the end of the stream. */ + for (;;) + { + SafeArray<BYTE> SafeArrayBuf; + + hrc = ptrDataStream->Read(_64K, 0 /*Infinite wait*/, ComSafeArrayAsOutParam(SafeArrayBuf)); + if ( FAILED(hrc) + || SafeArrayBuf.size() == 0) + break; + + /* Output the data. */ + size_t const cbReturned = SafeArrayBuf.size(); + if (cbReturned) + { + BYTE const *pbBuf = SafeArrayBuf.raw(); + int vrc = VINF_SUCCESS; + vrc = RTStrmWrite(pOut, pbBuf, cbReturned); + if (RT_FAILURE(vrc)) + { + rcExit = RTMsgErrorExitFailure("Error writing to '%s': %Rrc", pszOutput, vrc); + break; + } + } + + /** @todo Check progress. */ + } + } + else + { + com::GlueHandleComError(ptrMediumIO, "ConvertToStream()", hrc, __FILE__, __LINE__); + rcExit = RTEXITCODE_FAILURE; + } + + /* + * Close output. + */ + if (pOut != g_pStdOut) + { + int vrc = RTStrmClose(pOut); + if (RT_FAILURE(vrc)) + rcExit = RTMsgErrorExitFailure("Error closing '%s': %Rrc", pszOutput, vrc); + } + else + RTStrmSetMode(pOut, false, -1); + } + } + return rcExit; +} + + +RTEXITCODE handleMediumIO(HandlerArg *a) +{ + /* + * Parse image-option and sub-command. + */ + static const RTGETOPTDEF s_aOptions[] = + { + MEDIUMIOCOMMONOPT_DEFS(), + /* sub-commands */ + { "formatfat", 1000, RTGETOPT_REQ_NOTHING }, + { "cat", 1001, RTGETOPT_REQ_NOTHING }, + { "stream", 1002, RTGETOPT_REQ_NOTHING }, + }; + MEDIUMIOCOMMONOPT CommonOpts = { NULL, DeviceType_Null, NULL }; + + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0); + AssertRC(rc); + RTGETOPTUNION ValueUnion; + while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + MEDIUMIOCOMMONOPT_CASES(&CommonOpts); + + /* Sub-commands: */ + case 1000: + setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_FORMATFAT); + return handleMediumIOFormatFat(a, GetState.iNext, &CommonOpts); + case 1001: + setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_CAT); + return handleMediumIOCat(a, GetState.iNext, &CommonOpts); + case 1002: + setCurrentSubcommand(HELP_SCOPE_MEDIUMIO_STREAM); + return handleMediumIOStream(a, GetState.iNext, &CommonOpts); + + case VINF_GETOPT_NOT_OPTION: + return errorUnknownSubcommand(ValueUnion.psz); + + default: + return errorGetOpt(rc, &ValueUnion); + } + } + return errorNoSubcommand(); +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp new file mode 100644 index 00000000..8d0b3372 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp @@ -0,0 +1,3435 @@ +/* $Id: VBoxManageGuestCtrl.cpp $ */ +/** @file + * VBoxManage - Implementation of guestcontrol command. + */ + +/* + * Copyright (C) 2010-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxManage.h" +#include "VBoxManageGuestCtrl.h" + +#ifndef VBOX_ONLY_DOCS + +#include <VBox/com/array.h> +#include <VBox/com/com.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/listeners.h> +#include <VBox/com/NativeEventQueue.h> +#include <VBox/com/string.h> +#include <VBox/com/VirtualBox.h> + +#include <VBox/err.h> +#include <VBox/log.h> + +#include <iprt/asm.h> +#include <iprt/dir.h> +#include <iprt/file.h> +#include <iprt/getopt.h> +#include <iprt/list.h> +#include <iprt/path.h> +#include <iprt/process.h> /* For RTProcSelf(). */ +#include <iprt/thread.h> +#include <iprt/vfs.h> + +#include <map> +#include <vector> + +#ifdef USE_XPCOM_QUEUE +# include <sys/select.h> +# include <errno.h> +#endif + +#include <signal.h> + +#ifdef RT_OS_DARWIN +# include <CoreFoundation/CFRunLoop.h> +#endif + +using namespace com; + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#define GCTLCMD_COMMON_OPT_USER 999 /**< The --username option number. */ +#define GCTLCMD_COMMON_OPT_PASSWORD 998 /**< The --password option number. */ +#define GCTLCMD_COMMON_OPT_PASSWORD_FILE 997 /**< The --password-file option number. */ +#define GCTLCMD_COMMON_OPT_DOMAIN 996 /**< The --domain option number. */ +/** Common option definitions. */ +#define GCTLCMD_COMMON_OPTION_DEFS() \ + { "--username", GCTLCMD_COMMON_OPT_USER, RTGETOPT_REQ_STRING }, \ + { "--passwordfile", GCTLCMD_COMMON_OPT_PASSWORD_FILE, RTGETOPT_REQ_STRING }, \ + { "--password", GCTLCMD_COMMON_OPT_PASSWORD, RTGETOPT_REQ_STRING }, \ + { "--domain", GCTLCMD_COMMON_OPT_DOMAIN, RTGETOPT_REQ_STRING }, \ + { "--quiet", 'q', RTGETOPT_REQ_NOTHING }, \ + { "--verbose", 'v', RTGETOPT_REQ_NOTHING }, + +/** Handles common options in the typical option parsing switch. */ +#define GCTLCMD_COMMON_OPTION_CASES(a_pCtx, a_ch, a_pValueUnion) \ + case 'v': \ + case 'q': \ + case GCTLCMD_COMMON_OPT_USER: \ + case GCTLCMD_COMMON_OPT_DOMAIN: \ + case GCTLCMD_COMMON_OPT_PASSWORD: \ + case GCTLCMD_COMMON_OPT_PASSWORD_FILE: \ + { \ + RTEXITCODE rcExitCommon = gctlCtxSetOption(a_pCtx, a_ch, a_pValueUnion); \ + if (RT_UNLIKELY(rcExitCommon != RTEXITCODE_SUCCESS)) \ + return rcExitCommon; \ + } break + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Set by the signal handler when current guest control + * action shall be aborted. */ +static volatile bool g_fGuestCtrlCanceled = false; + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Listener declarations. + */ +VBOX_LISTENER_DECLARE(GuestFileEventListenerImpl) +VBOX_LISTENER_DECLARE(GuestProcessEventListenerImpl) +VBOX_LISTENER_DECLARE(GuestSessionEventListenerImpl) +VBOX_LISTENER_DECLARE(GuestEventListenerImpl) + + +/** + * Definition of a guestcontrol command, with handler and various flags. + */ +typedef struct GCTLCMDDEF +{ + /** The command name. */ + const char *pszName; + + /** + * Actual command handler callback. + * + * @param pCtx Pointer to command context to use. + */ + DECLR3CALLBACKMEMBER(RTEXITCODE, pfnHandler, (struct GCTLCMDCTX *pCtx, int argc, char **argv)); + + /** The command usage flags. */ + uint32_t fCmdUsage; + /** Command context flags (GCTLCMDCTX_F_XXX). */ + uint32_t fCmdCtx; +} GCTLCMD; +/** Pointer to a const guest control command definition. */ +typedef GCTLCMDDEF const *PCGCTLCMDDEF; + +/** @name GCTLCMDCTX_F_XXX - Command context flags. + * @{ + */ +/** No flags set. */ +#define GCTLCMDCTX_F_NONE 0 +/** Don't install a signal handler (CTRL+C trap). */ +#define GCTLCMDCTX_F_NO_SIGNAL_HANDLER RT_BIT(0) +/** No guest session needed. */ +#define GCTLCMDCTX_F_SESSION_ANONYMOUS RT_BIT(1) +/** @} */ + +/** + * Context for handling a specific command. + */ +typedef struct GCTLCMDCTX +{ + HandlerArg *pArg; + + /** Pointer to the command definition. */ + PCGCTLCMDDEF pCmdDef; + /** The VM name or UUID. */ + const char *pszVmNameOrUuid; + + /** Whether we've done the post option parsing init already. */ + bool fPostOptionParsingInited; + /** Whether we've locked the VM session. */ + bool fLockedVmSession; + /** Whether to detach (@c true) or close the session. */ + bool fDetachGuestSession; + /** Set if we've installed the signal handler. */ + bool fInstalledSignalHandler; + /** The verbosity level. */ + uint32_t cVerbose; + /** User name. */ + Utf8Str strUsername; + /** Password. */ + Utf8Str strPassword; + /** Domain. */ + Utf8Str strDomain; + /** Pointer to the IGuest interface. */ + ComPtr<IGuest> pGuest; + /** Pointer to the to be used guest session. */ + ComPtr<IGuestSession> pGuestSession; + /** The guest session ID. */ + ULONG uSessionID; + +} GCTLCMDCTX, *PGCTLCMDCTX; + + +/** + * An entry for an element which needs to be copied/created to/on the guest. + */ +typedef struct DESTFILEENTRY +{ + DESTFILEENTRY(Utf8Str strFilename) : mFilename(strFilename) {} + Utf8Str mFilename; +} DESTFILEENTRY, *PDESTFILEENTRY; +/* + * Map for holding destination entries, whereas the key is the destination + * directory and the mapped value is a vector holding all elements for this directory. + */ +typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> > DESTDIRMAP, *PDESTDIRMAP; +typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> >::iterator DESTDIRMAPITER, *PDESTDIRMAPITER; + + +/** + * RTGetOpt-IDs for the guest execution control command line. + */ +enum GETOPTDEF_EXEC +{ + GETOPTDEF_EXEC_IGNOREORPHANEDPROCESSES = 1000, + GETOPTDEF_EXEC_NO_PROFILE, + GETOPTDEF_EXEC_OUTPUTFORMAT, + GETOPTDEF_EXEC_DOS2UNIX, + GETOPTDEF_EXEC_UNIX2DOS, + GETOPTDEF_EXEC_WAITFOREXIT, + GETOPTDEF_EXEC_WAITFORSTDOUT, + GETOPTDEF_EXEC_WAITFORSTDERR +}; + +enum kStreamTransform +{ + kStreamTransform_None = 0, + kStreamTransform_Dos2Unix, + kStreamTransform_Unix2Dos +}; +#endif /* VBOX_ONLY_DOCS */ + + +void usageGuestControl(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2, uint32_t uSubCmd) +{ + const uint32_t fAnonSubCmds = USAGE_GSTCTRL_CLOSESESSION + | USAGE_GSTCTRL_LIST + | USAGE_GSTCTRL_CLOSEPROCESS + | USAGE_GSTCTRL_CLOSESESSION + | USAGE_GSTCTRL_UPDATEGA + | USAGE_GSTCTRL_WATCH; + + /* 0 1 2 3 4 5 6 7 8XXXXXXXXXX */ + /* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 */ + if (~fAnonSubCmds & uSubCmd) + RTStrmPrintf(pStrm, + "%s guestcontrol %s <uuid|vmname> [--verbose|-v] [--quiet|-q]\n" + " [--username <name>] [--domain <domain>]\n" + " [--passwordfile <file> | --password <password>]\n%s", + pcszSep1, pcszSep2, uSubCmd == ~0U ? "\n" : ""); + if (uSubCmd & USAGE_GSTCTRL_RUN) + RTStrmPrintf(pStrm, + " run [common-options]\n" + " [--exe <path to executable>] [--timeout <msec>]\n" + " [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n" + " [--ignore-operhaned-processes] [--profile]\n" + " [--no-wait-stdout|--wait-stdout]\n" + " [--no-wait-stderr|--wait-stderr]\n" + " [--dos2unix] [--unix2dos]\n" + " -- <program/arg0> [argument1] ... [argumentN]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_START) + RTStrmPrintf(pStrm, + " start [common-options]\n" + " [--exe <path to executable>] [--timeout <msec>]\n" + " [-E|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n" + " [--ignore-operhaned-processes] [--profile]\n" + " -- <program/arg0> [argument1] ... [argumentN]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_COPYFROM) + RTStrmPrintf(pStrm, + " copyfrom [common-options]\n" + " [--follow] [-R|--recursive]\n" + " <guest-src0> [guest-src1 [...]] <host-dst>\n" + "\n" + " copyfrom [common-options]\n" + " [--follow] [-R|--recursive]\n" + " [--target-directory <host-dst-dir>]\n" + " <guest-src0> [guest-src1 [...]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_COPYTO) + RTStrmPrintf(pStrm, + " copyto [common-options]\n" + " [--follow] [-R|--recursive]\n" + " <host-src0> [host-src1 [...]] <guest-dst>\n" + "\n" + " copyto [common-options]\n" + " [--follow] [-R|--recursive]\n" + " [--target-directory <guest-dst>]\n" + " <host-src0> [host-src1 [...]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_MKDIR) + RTStrmPrintf(pStrm, + " mkdir|createdir[ectory] [common-options]\n" + " [--parents] [--mode <mode>]\n" + " <guest directory> [...]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_RMDIR) + RTStrmPrintf(pStrm, + " rmdir|removedir[ectory] [common-options]\n" + " [-R|--recursive]\n" + " <guest directory> [...]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_RM) + RTStrmPrintf(pStrm, + " removefile|rm [common-options] [-f|--force]\n" + " <guest file> [...]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_MV) + RTStrmPrintf(pStrm, + " mv|move|ren[ame] [common-options]\n" + " <source> [source1 [...]] <dest>\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_MKTEMP) + RTStrmPrintf(pStrm, + " mktemp|createtemp[orary] [common-options]\n" + " [--secure] [--mode <mode>] [--tmpdir <directory>]\n" + " <template>\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_STAT) + RTStrmPrintf(pStrm, + " stat [common-options]\n" + " <file> [...]\n" + "\n"); + + /* + * Command not requiring authentication. + */ + if (fAnonSubCmds & uSubCmd) + { + /* 0 1 2 3 4 5 6 7 8XXXXXXXXXX */ + /* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 */ + RTStrmPrintf(pStrm, + "%s guestcontrol %s <uuid|vmname> [--verbose|-v] [--quiet|-q]\n%s", + pcszSep1, pcszSep2, uSubCmd == ~0U ? "\n" : ""); + if (uSubCmd & USAGE_GSTCTRL_LIST) + RTStrmPrintf(pStrm, + " list <all|sessions|processes|files> [common-opts]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_CLOSEPROCESS) + RTStrmPrintf(pStrm, + " closeprocess [common-options]\n" + " < --session-id <ID>\n" + " | --session-name <name or pattern>\n" + " <PID1> [PID1 [...]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_CLOSESESSION) + RTStrmPrintf(pStrm, + " closesession [common-options]\n" + " < --all | --session-id <ID>\n" + " | --session-name <name or pattern> >\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_UPDATEGA) + RTStrmPrintf(pStrm, + " updatega|updateguestadditions|updateadditions\n" + " [--source <guest additions .ISO>]\n" + " [--wait-start] [common-options]\n" + " [-- [<argument1>] ... [<argumentN>]]\n" + "\n"); + if (uSubCmd & USAGE_GSTCTRL_WATCH) + RTStrmPrintf(pStrm, + " watch [common-options]\n" + "\n"); + } +} + +#ifndef VBOX_ONLY_DOCS + + +#ifdef RT_OS_WINDOWS +static BOOL WINAPI gctlSignalHandler(DWORD dwCtrlType) +{ + bool fEventHandled = FALSE; + switch (dwCtrlType) + { + /* User pressed CTRL+C or CTRL+BREAK or an external event was sent + * via GenerateConsoleCtrlEvent(). */ + case CTRL_BREAK_EVENT: + case CTRL_CLOSE_EVENT: + case CTRL_C_EVENT: + ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true); + fEventHandled = TRUE; + break; + default: + break; + /** @todo Add other events here. */ + } + + return fEventHandled; +} +#else /* !RT_OS_WINDOWS */ +/** + * Signal handler that sets g_fGuestCtrlCanceled. + * + * This can be executed on any thread in the process, on Windows it may even be + * a thread dedicated to delivering this signal. Don't do anything + * unnecessary here. + */ +static void gctlSignalHandler(int iSignal) +{ + NOREF(iSignal); + ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true); +} +#endif + + +/** + * Installs a custom signal handler to get notified + * whenever the user wants to intercept the program. + * + * @todo Make this handler available for all VBoxManage modules? + */ +static int gctlSignalHandlerInstall(void) +{ + g_fGuestCtrlCanceled = false; + + int rc = VINF_SUCCESS; +#ifdef RT_OS_WINDOWS + if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)gctlSignalHandler, TRUE /* Add handler */)) + { + rc = RTErrConvertFromWin32(GetLastError()); + RTMsgError("Unable to install console control handler, rc=%Rrc\n", rc); + } +#else + signal(SIGINT, gctlSignalHandler); + signal(SIGTERM, gctlSignalHandler); +# ifdef SIGBREAK + signal(SIGBREAK, gctlSignalHandler); +# endif +#endif + return rc; +} + + +/** + * Uninstalls a previously installed signal handler. + */ +static int gctlSignalHandlerUninstall(void) +{ + int rc = VINF_SUCCESS; +#ifdef RT_OS_WINDOWS + if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */)) + { + rc = RTErrConvertFromWin32(GetLastError()); + RTMsgError("Unable to uninstall console control handler, rc=%Rrc\n", rc); + } +#else + signal(SIGINT, SIG_DFL); + signal(SIGTERM, SIG_DFL); +# ifdef SIGBREAK + signal(SIGBREAK, SIG_DFL); +# endif +#endif + return rc; +} + + +/** + * Translates a process status to a human readable string. + */ +const char *gctlProcessStatusToText(ProcessStatus_T enmStatus) +{ + switch (enmStatus) + { + case ProcessStatus_Starting: + return "starting"; + case ProcessStatus_Started: + return "started"; + case ProcessStatus_Paused: + return "paused"; + case ProcessStatus_Terminating: + return "terminating"; + case ProcessStatus_TerminatedNormally: + return "successfully terminated"; + case ProcessStatus_TerminatedSignal: + return "terminated by signal"; + case ProcessStatus_TerminatedAbnormally: + return "abnormally aborted"; + case ProcessStatus_TimedOutKilled: + return "timed out"; + case ProcessStatus_TimedOutAbnormally: + return "timed out, hanging"; + case ProcessStatus_Down: + return "killed"; + case ProcessStatus_Error: + return "error"; + default: + break; + } + return "unknown"; +} + +/** + * Translates a guest process wait result to a human readable string. + */ +const char *gctlProcessWaitResultToText(ProcessWaitResult_T enmWaitResult) +{ + switch (enmWaitResult) + { + case ProcessWaitResult_Start: + return "started"; + case ProcessWaitResult_Terminate: + return "terminated"; + case ProcessWaitResult_Status: + return "status changed"; + case ProcessWaitResult_Error: + return "error"; + case ProcessWaitResult_Timeout: + return "timed out"; + case ProcessWaitResult_StdIn: + return "stdin ready"; + case ProcessWaitResult_StdOut: + return "data on stdout"; + case ProcessWaitResult_StdErr: + return "data on stderr"; + case ProcessWaitResult_WaitFlagNotSupported: + return "waiting flag not supported"; + default: + break; + } + return "unknown"; +} + +/** + * Translates a guest session status to a human readable string. + */ +const char *gctlGuestSessionStatusToText(GuestSessionStatus_T enmStatus) +{ + switch (enmStatus) + { + case GuestSessionStatus_Starting: + return "starting"; + case GuestSessionStatus_Started: + return "started"; + case GuestSessionStatus_Terminating: + return "terminating"; + case GuestSessionStatus_Terminated: + return "terminated"; + case GuestSessionStatus_TimedOutKilled: + return "timed out"; + case GuestSessionStatus_TimedOutAbnormally: + return "timed out, hanging"; + case GuestSessionStatus_Down: + return "killed"; + case GuestSessionStatus_Error: + return "error"; + default: + break; + } + return "unknown"; +} + +/** + * Translates a guest file status to a human readable string. + */ +const char *gctlFileStatusToText(FileStatus_T enmStatus) +{ + switch (enmStatus) + { + case FileStatus_Opening: + return "opening"; + case FileStatus_Open: + return "open"; + case FileStatus_Closing: + return "closing"; + case FileStatus_Closed: + return "closed"; + case FileStatus_Down: + return "killed"; + case FileStatus_Error: + return "error"; + default: + break; + } + return "unknown"; +} + +/** + * Translates a file system objec type to a string. + */ +const char *gctlFsObjTypeToName(FsObjType_T enmType) +{ + switch (enmType) + { + case FsObjType_Unknown: return "unknown"; + case FsObjType_Fifo: return "fifo"; + case FsObjType_DevChar: return "char-device"; + case FsObjType_Directory: return "directory"; + case FsObjType_DevBlock: return "block-device"; + case FsObjType_File: return "file"; + case FsObjType_Symlink: return "symlink"; + case FsObjType_Socket: return "socket"; + case FsObjType_WhiteOut: return "white-out"; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case FsObjType_32BitHack: break; +#endif + } + return "unknown"; +} + +static int gctlPrintError(com::ErrorInfo &errorInfo) +{ + if ( errorInfo.isFullAvailable() + || errorInfo.isBasicAvailable()) + { + /* If we got a VBOX_E_IPRT error we handle the error in a more gentle way + * because it contains more accurate info about what went wrong. */ + if (errorInfo.getResultCode() == VBOX_E_IPRT_ERROR) + RTMsgError("%ls.", errorInfo.getText().raw()); + else + { + RTMsgError("Error details:"); + GluePrintErrorInfo(errorInfo); + } + return VERR_GENERAL_FAILURE; /** @todo */ + } + AssertMsgFailedReturn(("Object has indicated no error (%Rhrc)!?\n", errorInfo.getResultCode()), + VERR_INVALID_PARAMETER); +} + +static int gctlPrintError(IUnknown *pObj, const GUID &aIID) +{ + com::ErrorInfo ErrInfo(pObj, aIID); + return gctlPrintError(ErrInfo); +} + +static int gctlPrintProgressError(ComPtr<IProgress> pProgress) +{ + int vrc = VINF_SUCCESS; + HRESULT rc; + + do + { + BOOL fCanceled; + CHECK_ERROR_BREAK(pProgress, COMGETTER(Canceled)(&fCanceled)); + if (!fCanceled) + { + LONG rcProc; + CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&rcProc)); + if (FAILED(rcProc)) + { + com::ProgressErrorInfo ErrInfo(pProgress); + vrc = gctlPrintError(ErrInfo); + } + } + + } while(0); + + AssertMsgStmt(SUCCEEDED(rc), ("Could not lookup progress information\n"), vrc = VERR_COM_UNEXPECTED); + + return vrc; +} + + + +/* + * + * + * Guest Control Command Context + * Guest Control Command Context + * Guest Control Command Context + * Guest Control Command Context + * + * + * + */ + + +/** + * Initializes a guest control command context structure. + * + * @returns RTEXITCODE_SUCCESS on success, RTEXITCODE_FAILURE on failure (after + * informing the user of course). + * @param pCtx The command context to init. + * @param pArg The handle argument package. + */ +static RTEXITCODE gctrCmdCtxInit(PGCTLCMDCTX pCtx, HandlerArg *pArg) +{ + RT_ZERO(*pCtx); + pCtx->pArg = pArg; + + /* + * The user name defaults to the host one, if we can get at it. + */ + char szUser[1024]; + int rc = RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), NULL); + if ( RT_SUCCESS(rc) + && RTStrIsValidEncoding(szUser)) /* paranoia required on posix */ + { + try + { + pCtx->strUsername = szUser; + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory"); + } + } + /* else: ignore this failure. */ + + return RTEXITCODE_SUCCESS; +} + + +/** + * Worker for GCTLCMD_COMMON_OPTION_CASES. + * + * @returns RTEXITCODE_SUCCESS if the option was handled successfully. If not, + * an error message is printed and an appropriate failure exit code is + * returned. + * @param pCtx The guest control command context. + * @param ch The option char or ordinal. + * @param pValueUnion The option value union. + */ +static RTEXITCODE gctlCtxSetOption(PGCTLCMDCTX pCtx, int ch, PRTGETOPTUNION pValueUnion) +{ + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + switch (ch) + { + case GCTLCMD_COMMON_OPT_USER: /* User name */ + if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)) + pCtx->strUsername = pValueUnion->psz; + else + RTMsgWarning("The --username|-u option is ignored by '%s'", pCtx->pCmdDef->pszName); + break; + + case GCTLCMD_COMMON_OPT_PASSWORD: /* Password */ + if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)) + { + if (pCtx->strPassword.isNotEmpty()) + RTMsgWarning("Password is given more than once."); + pCtx->strPassword = pValueUnion->psz; + } + else + RTMsgWarning("The --password option is ignored by '%s'", pCtx->pCmdDef->pszName); + break; + + case GCTLCMD_COMMON_OPT_PASSWORD_FILE: /* Password file */ + if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)) + rcExit = readPasswordFile(pValueUnion->psz, &pCtx->strPassword); + else + RTMsgWarning("The --password-file|-p option is ignored by '%s'", pCtx->pCmdDef->pszName); + break; + + case GCTLCMD_COMMON_OPT_DOMAIN: /* domain */ + if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)) + pCtx->strDomain = pValueUnion->psz; + else + RTMsgWarning("The --domain option is ignored by '%s'", pCtx->pCmdDef->pszName); + break; + + case 'v': /* --verbose */ + pCtx->cVerbose++; + break; + + case 'q': /* --quiet */ + if (pCtx->cVerbose) + pCtx->cVerbose--; + break; + + default: + AssertFatalMsgFailed(("ch=%d (%c)\n", ch, ch)); + } + return rcExit; +} + + +/** + * Initializes the VM for IGuest operation. + * + * This opens a shared session to a running VM and gets hold of IGuest. + * + * @returns RTEXITCODE_SUCCESS on success. RTEXITCODE_FAILURE and user message + * on failure. + * @param pCtx The guest control command context. + * GCTLCMDCTX::pGuest will be set on success. + */ +static RTEXITCODE gctlCtxInitVmSession(PGCTLCMDCTX pCtx) +{ + HRESULT rc; + AssertPtr(pCtx); + AssertPtr(pCtx->pArg); + + /* + * Find the VM and check if it's running. + */ + ComPtr<IMachine> machine; + CHECK_ERROR(pCtx->pArg->virtualBox, FindMachine(Bstr(pCtx->pszVmNameOrUuid).raw(), machine.asOutParam())); + if (SUCCEEDED(rc)) + { + MachineState_T enmMachineState; + CHECK_ERROR(machine, COMGETTER(State)(&enmMachineState)); + if ( SUCCEEDED(rc) + && enmMachineState == MachineState_Running) + { + /* + * It's running. So, open a session to it and get the IGuest interface. + */ + CHECK_ERROR(machine, LockMachine(pCtx->pArg->session, LockType_Shared)); + if (SUCCEEDED(rc)) + { + pCtx->fLockedVmSession = true; + ComPtr<IConsole> ptrConsole; + CHECK_ERROR(pCtx->pArg->session, COMGETTER(Console)(ptrConsole.asOutParam())); + if (SUCCEEDED(rc)) + { + if (ptrConsole.isNotNull()) + { + CHECK_ERROR(ptrConsole, COMGETTER(Guest)(pCtx->pGuest.asOutParam())); + if (SUCCEEDED(rc)) + return RTEXITCODE_SUCCESS; + } + else + RTMsgError("Failed to get a IConsole pointer for the machine. Is it still running?\n"); + } + } + } + else if (SUCCEEDED(rc)) + RTMsgError("Machine \"%s\" is not running (currently %s)!\n", + pCtx->pszVmNameOrUuid, machineStateToName(enmMachineState, false)); + } + return RTEXITCODE_FAILURE; +} + + +/** + * Creates a guest session with the VM. + * + * @retval RTEXITCODE_SUCCESS on success. + * @retval RTEXITCODE_FAILURE and user message on failure. + * @param pCtx The guest control command context. + * GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID + * will be set. + */ +static RTEXITCODE gctlCtxInitGuestSession(PGCTLCMDCTX pCtx) +{ + HRESULT rc; + AssertPtr(pCtx); + Assert(!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)); + Assert(pCtx->pGuest.isNotNull()); + + /* + * Build up a reasonable guest session name. Useful for identifying + * a specific session when listing / searching for them. + */ + char *pszSessionName; + if (RTStrAPrintf(&pszSessionName, + "[%RU32] VBoxManage Guest Control [%s] - %s", + RTProcSelf(), pCtx->pszVmNameOrUuid, pCtx->pCmdDef->pszName) < 0) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "No enough memory for session name"); + + /* + * Create a guest session. + */ + if (pCtx->cVerbose) + RTPrintf("Creating guest session as user '%s'...\n", pCtx->strUsername.c_str()); + try + { + CHECK_ERROR(pCtx->pGuest, CreateSession(Bstr(pCtx->strUsername).raw(), + Bstr(pCtx->strPassword).raw(), + Bstr(pCtx->strDomain).raw(), + Bstr(pszSessionName).raw(), + pCtx->pGuestSession.asOutParam())); + } + catch (std::bad_alloc &) + { + RTMsgError("Out of memory setting up IGuest::CreateSession call"); + rc = E_OUTOFMEMORY; + } + if (SUCCEEDED(rc)) + { + /* + * Wait for guest session to start. + */ + if (pCtx->cVerbose) + RTPrintf("Waiting for guest session to start...\n"); + GuestSessionWaitResult_T enmWaitResult = GuestSessionWaitResult_None; /* Shut up MSC */ + try + { + com::SafeArray<GuestSessionWaitForFlag_T> aSessionWaitFlags; + aSessionWaitFlags.push_back(GuestSessionWaitForFlag_Start); + CHECK_ERROR(pCtx->pGuestSession, WaitForArray(ComSafeArrayAsInParam(aSessionWaitFlags), + /** @todo Make session handling timeouts configurable. */ + 30 * 1000, &enmWaitResult)); + } + catch (std::bad_alloc &) + { + RTMsgError("Out of memory setting up IGuestSession::WaitForArray call"); + rc = E_OUTOFMEMORY; + } + if (SUCCEEDED(rc)) + { + /* The WaitFlagNotSupported result may happen with GAs older than 4.3. */ + if ( enmWaitResult == GuestSessionWaitResult_Start + || enmWaitResult == GuestSessionWaitResult_WaitFlagNotSupported) + { + /* + * Get the session ID and we're ready to rumble. + */ + CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Id)(&pCtx->uSessionID)); + if (SUCCEEDED(rc)) + { + if (pCtx->cVerbose) + RTPrintf("Successfully started guest session (ID %RU32)\n", pCtx->uSessionID); + RTStrFree(pszSessionName); + return RTEXITCODE_SUCCESS; + } + } + else + { + GuestSessionStatus_T enmSessionStatus; + CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Status)(&enmSessionStatus)); + RTMsgError("Error starting guest session (current status is: %s)\n", + SUCCEEDED(rc) ? gctlGuestSessionStatusToText(enmSessionStatus) : "<unknown>"); + } + } + } + + RTStrFree(pszSessionName); + return RTEXITCODE_FAILURE; +} + + +/** + * Completes the guest control context initialization after parsing arguments. + * + * Will validate common arguments, open a VM session, and if requested open a + * guest session and install the CTRL-C signal handler. + * + * It is good to validate all the options and arguments you can before making + * this call. However, the VM session, IGuest and IGuestSession interfaces are + * not availabe till after this call, so take care. + * + * @retval RTEXITCODE_SUCCESS on success. + * @retval RTEXITCODE_FAILURE and user message on failure. + * @param pCtx The guest control command context. + * GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID + * will be set. + * @remarks Can safely be called multiple times, will only do work once. + */ +static RTEXITCODE gctlCtxPostOptionParsingInit(PGCTLCMDCTX pCtx) +{ + if (pCtx->fPostOptionParsingInited) + return RTEXITCODE_SUCCESS; + + /* + * Check that the user name isn't empty when we need it. + */ + RTEXITCODE rcExit; + if ( (pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS) + || pCtx->strUsername.isNotEmpty()) + { + /* + * Open the VM session and if required, a guest session. + */ + rcExit = gctlCtxInitVmSession(pCtx); + if ( rcExit == RTEXITCODE_SUCCESS + && !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)) + rcExit = gctlCtxInitGuestSession(pCtx); + if (rcExit == RTEXITCODE_SUCCESS) + { + /* + * Install signal handler if requested (errors are ignored). + */ + if (!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_NO_SIGNAL_HANDLER)) + { + int rc = gctlSignalHandlerInstall(); + pCtx->fInstalledSignalHandler = RT_SUCCESS(rc); + } + } + } + else + rcExit = errorSyntaxEx(USAGE_GUESTCONTROL, pCtx->pCmdDef->fCmdUsage, "No user name specified!"); + + pCtx->fPostOptionParsingInited = rcExit == RTEXITCODE_SUCCESS; + return rcExit; +} + + +/** + * Cleans up the context when the command returns. + * + * This will close any open guest session, unless the DETACH flag is set. + * It will also close any VM session that may be been established. Any signal + * handlers we've installed will also be removed. + * + * Un-initializes the VM after guest control usage. + * @param pCmdCtx Pointer to command context. + */ +static void gctlCtxTerm(PGCTLCMDCTX pCtx) +{ + HRESULT rc; + AssertPtr(pCtx); + + /* + * Uninstall signal handler. + */ + if (pCtx->fInstalledSignalHandler) + { + gctlSignalHandlerUninstall(); + pCtx->fInstalledSignalHandler = false; + } + + /* + * Close, or at least release, the guest session. + */ + if (pCtx->pGuestSession.isNotNull()) + { + if ( !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS) + && !pCtx->fDetachGuestSession) + { + if (pCtx->cVerbose) + RTPrintf("Closing guest session ...\n"); + + CHECK_ERROR(pCtx->pGuestSession, Close()); + } + else if ( pCtx->fDetachGuestSession + && pCtx->cVerbose) + RTPrintf("Guest session detached\n"); + + pCtx->pGuestSession.setNull(); + } + + /* + * Close the VM session. + */ + if (pCtx->fLockedVmSession) + { + Assert(pCtx->pArg->session.isNotNull()); + CHECK_ERROR(pCtx->pArg->session, UnlockMachine()); + pCtx->fLockedVmSession = false; + } +} + + + + + +/* + * + * + * Guest Control Command Handling. + * Guest Control Command Handling. + * Guest Control Command Handling. + * Guest Control Command Handling. + * Guest Control Command Handling. + * + * + */ + + +/** @name EXITCODEEXEC_XXX - Special run exit codes. + * + * Special exit codes for returning errors/information of a started guest + * process to the command line VBoxManage was started from. Useful for e.g. + * scripting. + * + * ASSUMING that all platforms have at least 7-bits for the exit code we can do + * the following mapping: + * - Guest exit code 0 is mapped to 0 on the host. + * - Guest exit codes 1 thru 93 (0x5d) are displaced by 32, so that 1 + * becomes 33 (0x21) on the host and 93 becomes 125 (0x7d) on the host. + * - Guest exit codes 94 (0x5e) and above are mapped to 126 (0x5e). + * + * We ASSUME that all VBoxManage status codes are in the range 0 thru 32. + * + * @note These are frozen as of 4.1.0. + * @note The guest exit code mappings was introduced with 5.0 and the 'run' + * command, they are/was not supported by 'exec'. + * @sa gctlRunCalculateExitCode + */ +/** Process exited normally but with an exit code <> 0. */ +#define EXITCODEEXEC_CODE ((RTEXITCODE)16) +#define EXITCODEEXEC_FAILED ((RTEXITCODE)17) +#define EXITCODEEXEC_TERM_SIGNAL ((RTEXITCODE)18) +#define EXITCODEEXEC_TERM_ABEND ((RTEXITCODE)19) +#define EXITCODEEXEC_TIMEOUT ((RTEXITCODE)20) +#define EXITCODEEXEC_DOWN ((RTEXITCODE)21) +/** Execution was interrupt by user (ctrl-c). */ +#define EXITCODEEXEC_CANCELED ((RTEXITCODE)22) +/** The first mapped guest (non-zero) exit code. */ +#define EXITCODEEXEC_MAPPED_FIRST 33 +/** The last mapped guest (non-zero) exit code value (inclusive). */ +#define EXITCODEEXEC_MAPPED_LAST 125 +/** The number of exit codes from EXITCODEEXEC_MAPPED_FIRST to + * EXITCODEEXEC_MAPPED_LAST. This is also the highest guest exit code number + * we're able to map. */ +#define EXITCODEEXEC_MAPPED_RANGE (93) +/** The guest exit code displacement value. */ +#define EXITCODEEXEC_MAPPED_DISPLACEMENT 32 +/** The guest exit code was too big to be mapped. */ +#define EXITCODEEXEC_MAPPED_BIG ((RTEXITCODE)126) +/** @} */ + +/** + * Calculates the exit code of VBoxManage. + * + * @returns The exit code to return. + * @param enmStatus The guest process status. + * @param uExitCode The associated guest process exit code (where + * applicable). + * @param fReturnExitCodes Set if we're to use the 32-126 range for guest + * exit codes. + */ +static RTEXITCODE gctlRunCalculateExitCode(ProcessStatus_T enmStatus, ULONG uExitCode, bool fReturnExitCodes) +{ + switch (enmStatus) + { + case ProcessStatus_TerminatedNormally: + if (uExitCode == 0) + return RTEXITCODE_SUCCESS; + if (!fReturnExitCodes) + return EXITCODEEXEC_CODE; + if (uExitCode <= EXITCODEEXEC_MAPPED_RANGE) + return (RTEXITCODE) (uExitCode + EXITCODEEXEC_MAPPED_DISPLACEMENT); + return EXITCODEEXEC_MAPPED_BIG; + + case ProcessStatus_TerminatedAbnormally: + return EXITCODEEXEC_TERM_ABEND; + case ProcessStatus_TerminatedSignal: + return EXITCODEEXEC_TERM_SIGNAL; + +#if 0 /* see caller! */ + case ProcessStatus_TimedOutKilled: + return EXITCODEEXEC_TIMEOUT; + case ProcessStatus_Down: + return EXITCODEEXEC_DOWN; /* Service/OS is stopping, process was killed. */ + case ProcessStatus_Error: + return EXITCODEEXEC_FAILED; + + /* The following is probably for detached? */ + case ProcessStatus_Starting: + return RTEXITCODE_SUCCESS; + case ProcessStatus_Started: + return RTEXITCODE_SUCCESS; + case ProcessStatus_Paused: + return RTEXITCODE_SUCCESS; + case ProcessStatus_Terminating: + return RTEXITCODE_SUCCESS; /** @todo ???? */ +#endif + + default: + AssertMsgFailed(("Unknown exit status (%u/%u) from guest process returned!\n", enmStatus, uExitCode)); + return RTEXITCODE_FAILURE; + } +} + + +/** + * Pumps guest output to the host. + * + * @return IPRT status code. + * @param pProcess Pointer to appropriate process object. + * @param hVfsIosDst Where to write the data. + * @param uHandle Handle where to read the data from. + * @param cMsTimeout Timeout (in ms) to wait for the operation to + * complete. + */ +static int gctlRunPumpOutput(IProcess *pProcess, RTVFSIOSTREAM hVfsIosDst, ULONG uHandle, RTMSINTERVAL cMsTimeout) +{ + AssertPtrReturn(pProcess, VERR_INVALID_POINTER); + Assert(hVfsIosDst != NIL_RTVFSIOSTREAM); + + int vrc; + + SafeArray<BYTE> aOutputData; + HRESULT hrc = pProcess->Read(uHandle, _64K, RT_MAX(cMsTimeout, 1), ComSafeArrayAsOutParam(aOutputData)); + if (SUCCEEDED(hrc)) + { + size_t cbOutputData = aOutputData.size(); + if (cbOutputData == 0) + vrc = VINF_SUCCESS; + else + { + BYTE const *pbBuf = aOutputData.raw(); + AssertPtr(pbBuf); + + vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /*fBlocking*/, NULL); + if (RT_FAILURE(vrc)) + RTMsgError("Unable to write output, rc=%Rrc\n", vrc); + } + } + else + vrc = gctlPrintError(pProcess, COM_IIDOF(IProcess)); + return vrc; +} + + +/** + * Configures a host handle for pumping guest bits. + * + * @returns true if enabled and we successfully configured it. + * @param fEnabled Whether pumping this pipe is configured. + * @param enmHandle The IPRT standard handle designation. + * @param pszName The name for user messages. + * @param enmTransformation The transformation to apply. + * @param phVfsIos Where to return the resulting I/O stream handle. + */ +static bool gctlRunSetupHandle(bool fEnabled, RTHANDLESTD enmHandle, const char *pszName, + kStreamTransform enmTransformation, PRTVFSIOSTREAM phVfsIos) +{ + if (fEnabled) + { + int vrc = RTVfsIoStrmFromStdHandle(enmHandle, 0, true /*fLeaveOpen*/, phVfsIos); + if (RT_SUCCESS(vrc)) + { + if (enmTransformation != kStreamTransform_None) + { + RTMsgWarning("Unsupported %s line ending conversion", pszName); + /** @todo Implement dos2unix and unix2dos stream filters. */ + } + return true; + } + RTMsgWarning("Error getting %s handle: %Rrc", pszName, vrc); + } + return false; +} + + +/** + * Returns the remaining time (in ms) based on the start time and a set + * timeout value. Returns RT_INDEFINITE_WAIT if no timeout was specified. + * + * @return RTMSINTERVAL Time left (in ms). + * @param u64StartMs Start time (in ms). + * @param cMsTimeout Timeout value (in ms). + */ +static RTMSINTERVAL gctlRunGetRemainingTime(uint64_t u64StartMs, RTMSINTERVAL cMsTimeout) +{ + if (!cMsTimeout || cMsTimeout == RT_INDEFINITE_WAIT) /* If no timeout specified, wait forever. */ + return RT_INDEFINITE_WAIT; + + uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs; + if (u64ElapsedMs >= cMsTimeout) + return 0; + + return cMsTimeout - (RTMSINTERVAL)u64ElapsedMs; +} + +/** + * Common handler for the 'run' and 'start' commands. + * + * @returns Command exit code. + * @param pCtx Guest session context. + * @param argc The argument count. + * @param argv The argument vector for this command. + * @param fRunCmd Set if it's 'run' clear if 'start'. + * @param fHelp The help flag for the command. + */ +static RTEXITCODE gctlHandleRunCommon(PGCTLCMDCTX pCtx, int argc, char **argv, bool fRunCmd, uint32_t fHelp) +{ + RT_NOREF(fHelp); + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + /* + * Parse arguments. + */ + enum kGstCtrlRunOpt + { + kGstCtrlRunOpt_IgnoreOrphanedProcesses = 1000, + kGstCtrlRunOpt_NoProfile, /** @todo Deprecated and will be removed soon; use kGstCtrlRunOpt_Profile instead, if needed. */ + kGstCtrlRunOpt_Profile, + kGstCtrlRunOpt_Dos2Unix, + kGstCtrlRunOpt_Unix2Dos, + kGstCtrlRunOpt_WaitForStdOut, + kGstCtrlRunOpt_NoWaitForStdOut, + kGstCtrlRunOpt_WaitForStdErr, + kGstCtrlRunOpt_NoWaitForStdErr + }; + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--putenv", 'E', RTGETOPT_REQ_STRING }, + { "--exe", 'e', RTGETOPT_REQ_STRING }, + { "--timeout", 't', RTGETOPT_REQ_UINT32 }, + { "--unquoted-args", 'u', RTGETOPT_REQ_NOTHING }, + { "--ignore-operhaned-processes", kGstCtrlRunOpt_IgnoreOrphanedProcesses, RTGETOPT_REQ_NOTHING }, + { "--no-profile", kGstCtrlRunOpt_NoProfile, RTGETOPT_REQ_NOTHING }, /** @todo Deprecated. */ + { "--profile", kGstCtrlRunOpt_Profile, RTGETOPT_REQ_NOTHING }, + /* run only: 6 - options */ + { "--dos2unix", kGstCtrlRunOpt_Dos2Unix, RTGETOPT_REQ_NOTHING }, + { "--unix2dos", kGstCtrlRunOpt_Unix2Dos, RTGETOPT_REQ_NOTHING }, + { "--no-wait-stdout", kGstCtrlRunOpt_NoWaitForStdOut, RTGETOPT_REQ_NOTHING }, + { "--wait-stdout", kGstCtrlRunOpt_WaitForStdOut, RTGETOPT_REQ_NOTHING }, + { "--no-wait-stderr", kGstCtrlRunOpt_NoWaitForStdErr, RTGETOPT_REQ_NOTHING }, + { "--wait-stderr", kGstCtrlRunOpt_WaitForStdErr, RTGETOPT_REQ_NOTHING }, + }; + + /** @todo stdin handling. */ + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions) - (fRunCmd ? 0 : 6), + 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRC(vrc); + + com::SafeArray<ProcessCreateFlag_T> aCreateFlags; + com::SafeArray<ProcessWaitForFlag_T> aWaitFlags; + com::SafeArray<IN_BSTR> aArgs; + com::SafeArray<IN_BSTR> aEnv; + const char * pszImage = NULL; + bool fWaitForStdOut = fRunCmd; + bool fWaitForStdErr = fRunCmd; + RTVFSIOSTREAM hVfsStdOut = NIL_RTVFSIOSTREAM; + RTVFSIOSTREAM hVfsStdErr = NIL_RTVFSIOSTREAM; + enum kStreamTransform enmStdOutTransform = kStreamTransform_None; + enum kStreamTransform enmStdErrTransform = kStreamTransform_None; + RTMSINTERVAL cMsTimeout = 0; + + try + { + /* Wait for process start in any case. This is useful for scripting VBoxManage + * when relying on its overall exit code. */ + aWaitFlags.push_back(ProcessWaitForFlag_Start); + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'E': + if ( ValueUnion.psz[0] == '\0' + || ValueUnion.psz[0] == '=') + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, + "Invalid argument variable[=value]: '%s'", ValueUnion.psz); + aEnv.push_back(Bstr(ValueUnion.psz).raw()); + break; + + case kGstCtrlRunOpt_IgnoreOrphanedProcesses: + aCreateFlags.push_back(ProcessCreateFlag_IgnoreOrphanedProcesses); + break; + + case kGstCtrlRunOpt_NoProfile: + /** @todo Deprecated, will be removed. */ + RTPrintf("Warning: Deprecated option \"--no-profile\" specified\n"); + break; + + case kGstCtrlRunOpt_Profile: + aCreateFlags.push_back(ProcessCreateFlag_Profile); + break; + + case 'e': + pszImage = ValueUnion.psz; + break; + + case 'u': + aCreateFlags.push_back(ProcessCreateFlag_UnquotedArguments); + break; + + /** @todo Add a hidden flag. */ + + case 't': /* Timeout */ + cMsTimeout = ValueUnion.u32; + break; + + /* run only options: */ + case kGstCtrlRunOpt_Dos2Unix: + Assert(fRunCmd); + enmStdErrTransform = enmStdOutTransform = kStreamTransform_Dos2Unix; + break; + case kGstCtrlRunOpt_Unix2Dos: + Assert(fRunCmd); + enmStdErrTransform = enmStdOutTransform = kStreamTransform_Unix2Dos; + break; + + case kGstCtrlRunOpt_WaitForStdOut: + Assert(fRunCmd); + fWaitForStdOut = true; + break; + case kGstCtrlRunOpt_NoWaitForStdOut: + Assert(fRunCmd); + fWaitForStdOut = false; + break; + + case kGstCtrlRunOpt_WaitForStdErr: + Assert(fRunCmd); + fWaitForStdErr = true; + break; + case kGstCtrlRunOpt_NoWaitForStdErr: + Assert(fRunCmd); + fWaitForStdErr = false; + break; + + case VINF_GETOPT_NOT_OPTION: + aArgs.push_back(Bstr(ValueUnion.psz).raw()); + if (!pszImage) + { + Assert(aArgs.size() == 1); + pszImage = ValueUnion.psz; + } + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, ch, &ValueUnion); + + } /* switch */ + } /* while RTGetOpt */ + + /* Must have something to execute. */ + if (!pszImage || !*pszImage) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, "No executable specified!"); + + /* + * Finalize process creation and wait flags and input/output streams. + */ + if (!fRunCmd) + { + aCreateFlags.push_back(ProcessCreateFlag_WaitForProcessStartOnly); + Assert(!fWaitForStdOut); + Assert(!fWaitForStdErr); + } + else + { + aWaitFlags.push_back(ProcessWaitForFlag_Terminate); + fWaitForStdOut = gctlRunSetupHandle(fWaitForStdOut, RTHANDLESTD_OUTPUT, "stdout", enmStdOutTransform, &hVfsStdOut); + if (fWaitForStdOut) + { + aCreateFlags.push_back(ProcessCreateFlag_WaitForStdOut); + aWaitFlags.push_back(ProcessWaitForFlag_StdOut); + } + fWaitForStdErr = gctlRunSetupHandle(fWaitForStdErr, RTHANDLESTD_ERROR, "stderr", enmStdErrTransform, &hVfsStdErr); + if (fWaitForStdErr) + { + aCreateFlags.push_back(ProcessCreateFlag_WaitForStdErr); + aWaitFlags.push_back(ProcessWaitForFlag_StdErr); + } + } + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "VERR_NO_MEMORY\n"); + } + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + HRESULT rc; + + try + { + do + { + /* Get current time stamp to later calculate rest of timeout left. */ + uint64_t msStart = RTTimeMilliTS(); + + /* + * Create the process. + */ + if (pCtx->cVerbose) + { + if (cMsTimeout == 0) + RTPrintf("Starting guest process ...\n"); + else + RTPrintf("Starting guest process (within %ums)\n", cMsTimeout); + } + ComPtr<IGuestProcess> pProcess; + CHECK_ERROR_BREAK(pCtx->pGuestSession, ProcessCreate(Bstr(pszImage).raw(), + ComSafeArrayAsInParam(aArgs), + ComSafeArrayAsInParam(aEnv), + ComSafeArrayAsInParam(aCreateFlags), + gctlRunGetRemainingTime(msStart, cMsTimeout), + pProcess.asOutParam())); + + /* + * Explicitly wait for the guest process to be in a started state. + */ + com::SafeArray<ProcessWaitForFlag_T> aWaitStartFlags; + aWaitStartFlags.push_back(ProcessWaitForFlag_Start); + ProcessWaitResult_T waitResult; + CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitStartFlags), + gctlRunGetRemainingTime(msStart, cMsTimeout), &waitResult)); + + ULONG uPID = 0; + CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID)); + if (fRunCmd && pCtx->cVerbose) + RTPrintf("Process '%s' (PID %RU32) started\n", pszImage, uPID); + else if (!fRunCmd && pCtx->cVerbose) + { + /* Just print plain PID to make it easier for scripts + * invoking VBoxManage. */ + RTPrintf("[%RU32 - Session %RU32]\n", uPID, pCtx->uSessionID); + } + + /* + * Wait for process to exit/start... + */ + RTMSINTERVAL cMsTimeLeft = 1; /* Will be calculated. */ + bool fReadStdOut = false; + bool fReadStdErr = false; + bool fCompleted = false; + bool fCompletedStartCmd = false; + + vrc = VINF_SUCCESS; + while ( !fCompleted + && cMsTimeLeft > 0) + { + cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout); + CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitFlags), + RT_MIN(500 /*ms*/, RT_MAX(cMsTimeLeft, 1 /*ms*/)), + &waitResult)); + switch (waitResult) + { + case ProcessWaitResult_Start: + fCompletedStartCmd = fCompleted = !fRunCmd; /* Only wait for startup if the 'start' command. */ + break; + case ProcessWaitResult_StdOut: + fReadStdOut = true; + break; + case ProcessWaitResult_StdErr: + fReadStdErr = true; + break; + case ProcessWaitResult_Terminate: + if (pCtx->cVerbose) + RTPrintf("Process terminated\n"); + /* Process terminated, we're done. */ + fCompleted = true; + break; + case ProcessWaitResult_WaitFlagNotSupported: + /* The guest does not support waiting for stdout/err, so + * yield to reduce the CPU load due to busy waiting. */ + RTThreadYield(); + fReadStdOut = fReadStdErr = true; + break; + case ProcessWaitResult_Timeout: + { + /** @todo It is really unclear whether we will get stuck with the timeout + * result here if the guest side times out the process and fails to + * kill the process... To be on the save side, double the IPC and + * check the process status every time we time out. */ + ProcessStatus_T enmProcStatus; + CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&enmProcStatus)); + if ( enmProcStatus == ProcessStatus_TimedOutKilled + || enmProcStatus == ProcessStatus_TimedOutAbnormally) + fCompleted = true; + fReadStdOut = fReadStdErr = true; + break; + } + case ProcessWaitResult_Status: + /* ignore. */ + break; + case ProcessWaitResult_Error: + /* waitFor is dead in the water, I think, so better leave the loop. */ + vrc = VERR_CALLBACK_RETURN; + break; + + case ProcessWaitResult_StdIn: AssertFailed(); /* did ask for this! */ break; + case ProcessWaitResult_None: AssertFailed(); /* used. */ break; + default: AssertFailed(); /* huh? */ break; + } + + if (g_fGuestCtrlCanceled) + break; + + /* + * Pump output as needed. + */ + if (fReadStdOut) + { + cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout); + int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdOut, 1 /* StdOut */, cMsTimeLeft); + if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc)) + vrc = vrc2; + fReadStdOut = false; + } + if (fReadStdErr) + { + cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout); + int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdErr, 2 /* StdErr */, cMsTimeLeft); + if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc)) + vrc = vrc2; + fReadStdErr = false; + } + if ( RT_FAILURE(vrc) + || g_fGuestCtrlCanceled) + break; + + /* + * Process events before looping. + */ + NativeEventQueue::getMainEventQueue()->processEventQueue(0); + } /* while */ + + /* + * Report status back to the user. + */ + if (g_fGuestCtrlCanceled) + { + if (pCtx->cVerbose) + RTPrintf("Process execution aborted!\n"); + rcExit = EXITCODEEXEC_CANCELED; + } + else if (fCompletedStartCmd) + { + if (pCtx->cVerbose) + RTPrintf("Process successfully started!\n"); + rcExit = RTEXITCODE_SUCCESS; + } + else if (fCompleted) + { + ProcessStatus_T procStatus; + CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&procStatus)); + if ( procStatus == ProcessStatus_TerminatedNormally + || procStatus == ProcessStatus_TerminatedAbnormally + || procStatus == ProcessStatus_TerminatedSignal) + { + LONG lExitCode; + CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode)); + if (pCtx->cVerbose) + RTPrintf("Exit code=%u (Status=%u [%s])\n", + lExitCode, procStatus, gctlProcessStatusToText(procStatus)); + + rcExit = gctlRunCalculateExitCode(procStatus, lExitCode, true /*fReturnExitCodes*/); + } + else if ( procStatus == ProcessStatus_TimedOutKilled + || procStatus == ProcessStatus_TimedOutAbnormally) + { + if (pCtx->cVerbose) + RTPrintf("Process timed out (guest side) and %s\n", + procStatus == ProcessStatus_TimedOutAbnormally + ? "failed to terminate so far" : "was terminated"); + rcExit = EXITCODEEXEC_TIMEOUT; + } + else + { + if (pCtx->cVerbose) + RTPrintf("Process now is in status [%s] (unexpected)\n", gctlProcessStatusToText(procStatus)); + rcExit = RTEXITCODE_FAILURE; + } + } + else if (RT_FAILURE_NP(vrc)) + { + if (pCtx->cVerbose) + RTPrintf("Process monitor loop quit with vrc=%Rrc\n", vrc); + rcExit = RTEXITCODE_FAILURE; + } + else + { + if (pCtx->cVerbose) + RTPrintf("Process monitor loop timed out\n"); + rcExit = EXITCODEEXEC_TIMEOUT; + } + + } while (0); + } + catch (std::bad_alloc &) + { + rc = E_OUTOFMEMORY; + } + + /* + * Decide what to do with the guest session. + * + * If it's the 'start' command where detach the guest process after + * starting, don't close the guest session it is part of, except on + * failure or ctrl-c. + * + * For the 'run' command the guest process quits with us. + */ + if (!fRunCmd && SUCCEEDED(rc) && !g_fGuestCtrlCanceled) + pCtx->fDetachGuestSession = true; + + /* Make sure we return failure on failure. */ + if (FAILED(rc) && rcExit == RTEXITCODE_SUCCESS) + rcExit = RTEXITCODE_FAILURE; + return rcExit; +} + + +static DECLCALLBACK(RTEXITCODE) gctlHandleRun(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + return gctlHandleRunCommon(pCtx, argc, argv, true /*fRunCmd*/, USAGE_GSTCTRL_RUN); +} + + +static DECLCALLBACK(RTEXITCODE) gctlHandleStart(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + return gctlHandleRunCommon(pCtx, argc, argv, false /*fRunCmd*/, USAGE_GSTCTRL_START); +} + + +static RTEXITCODE gctlHandleCopy(PGCTLCMDCTX pCtx, int argc, char **argv, bool fHostToGuest) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + /** @todo r=bird: This command isn't very unix friendly in general. mkdir + * is much better (partly because it is much simpler of course). The main + * arguments against this is that (1) all but two options conflicts with + * what 'man cp' tells me on a GNU/Linux system, (2) wildchar matching is + * done windows CMD style (though not in a 100% compatible way), and (3) + * that only one source is allowed - efficiently sabotaging default + * wildcard expansion by a unix shell. The best solution here would be + * two different variant, one windowsy (xcopy) and one unixy (gnu cp). */ + + /* + * IGuest::CopyToGuest is kept as simple as possible to let the developer choose + * what and how to implement the file enumeration/recursive lookup, like VBoxManage + * does in here. + */ + enum GETOPTDEF_COPY + { + GETOPTDEF_COPY_FOLLOW = 1000, + GETOPTDEF_COPY_TARGETDIR + }; + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--follow", GETOPTDEF_COPY_FOLLOW, RTGETOPT_REQ_NOTHING }, + { "--recursive", 'R', RTGETOPT_REQ_NOTHING }, + { "--target-directory", GETOPTDEF_COPY_TARGETDIR, RTGETOPT_REQ_STRING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + bool fDstMustBeDir = false; + const char *pszDst = NULL; + bool fFollow = false; + bool fRecursive = false; + uint32_t uUsage = fHostToGuest ? USAGE_GSTCTRL_COPYTO : USAGE_GSTCTRL_COPYFROM; + + int vrc = VINF_SUCCESS; + while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0 + && ch != VINF_GETOPT_NOT_OPTION) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case GETOPTDEF_COPY_FOLLOW: + fFollow = true; + break; + + case 'R': /* Recursive processing */ + fRecursive = true; + break; + + case GETOPTDEF_COPY_TARGETDIR: + pszDst = ValueUnion.psz; + fDstMustBeDir = true; + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, uUsage, ch, &ValueUnion); + } + } + + char **papszSources = RTGetOptNonOptionArrayPtr(&GetState); + size_t cSources = &argv[argc] - papszSources; + + if (!cSources) + return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No sources specified!"); + + /* Unless a --target-directory is given, the last argument is the destination, so + bump it from the source list. */ + if (pszDst == NULL && cSources >= 2) + pszDst = papszSources[--cSources]; + + if (pszDst == NULL) + return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No destination specified!"); + + char szAbsDst[RTPATH_MAX]; + if (!fHostToGuest) + { + vrc = RTPathAbs(pszDst, szAbsDst, sizeof(szAbsDst)); + if (RT_SUCCESS(vrc)) + pszDst = szAbsDst; + else + return RTMsgErrorExitFailure("RTPathAbs failed on '%s': %Rrc", pszDst, vrc); + } + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + /* + * Done parsing arguments, do some more preparations. + */ + if (pCtx->cVerbose) + { + if (fHostToGuest) + RTPrintf("Copying from host to guest ...\n"); + else + RTPrintf("Copying from guest to host ...\n"); + } + + HRESULT rc = S_OK; + ComPtr<IProgress> pProgress; +/** @todo r=bird: This codes does nothing to handle the case where there are + * multiple sources. You need to do serveral thing before thats handled + * correctly. For starters the progress object handling needs to be moved + * inside the loop. Next you need to check what the destination is, because you + * can only copy multiple source files/directories to another directory. You + * actually need to check whether the target exists and is a directory + * regardless of you have 1 or 10 source files/dirs. + * + * Btw. the original approach to error handling here was APPALING. If some file + * couldn't be stat'ed or if it was a file/directory, you only spat out messages + * in verbose mode and never set the status code. + * + * The handling of the wildcard filtering expressions in sources was also just + * skipped. I've corrected this, but you still need to make up your mind wrt + * wildcards or not. + * + * Update: I've kicked out the whole SourceFileEntry/vecSources stuff as we can + * use argv directly without any unnecessary copying. You just have to + * look for the wildcards inside this loop instead. + */ + NOREF(fDstMustBeDir); + if (cSources != 1) + return RTMsgErrorExitFailure("Only one source file or directory at the moment."); + for (size_t iSrc = 0; iSrc < cSources; iSrc++) + { + const char *pszSource = papszSources[iSrc]; + + /* Check if the source contains any wilecards in the last component, if so we + don't know how to deal with it yet and refuse. */ + const char *pszSrcFinalComp = RTPathFilename(pszSource); + if (pszSrcFinalComp && strpbrk(pszSrcFinalComp, "*?")) + rcExit = RTMsgErrorExitFailure("Skipping '%s' because wildcard expansion isn't implemented yet\n", pszSource); + else if (fHostToGuest) + { + /* + * Source is host, destiation guest. + */ + char szAbsSrc[RTPATH_MAX]; + vrc = RTPathAbs(pszSource, szAbsSrc, sizeof(szAbsSrc)); + if (RT_SUCCESS(vrc)) + { + RTFSOBJINFO ObjInfo; + vrc = RTPathQueryInfo(szAbsSrc, &ObjInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(vrc)) + { + if (RTFS_IS_FILE(ObjInfo.Attr.fMode)) + { + if (pCtx->cVerbose) + RTPrintf("File '%s' -> '%s'\n", szAbsSrc, pszDst); + + SafeArray<FileCopyFlag_T> copyFlags; + rc = pCtx->pGuestSession->FileCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(), + ComSafeArrayAsInParam(copyFlags), pProgress.asOutParam()); + } + else if (RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode)) + { + if (pCtx->cVerbose) + RTPrintf("Directory '%s' -> '%s'\n", szAbsSrc, pszDst); + + SafeArray<DirectoryCopyFlag_T> copyFlags; + copyFlags.push_back(DirectoryCopyFlag_CopyIntoExisting); + rc = pCtx->pGuestSession->DirectoryCopyToGuest(Bstr(szAbsSrc).raw(), Bstr(pszDst).raw(), + ComSafeArrayAsInParam(copyFlags), pProgress.asOutParam()); + } + else + rcExit = RTMsgErrorExitFailure("Not a file or directory: %s\n", szAbsSrc); + } + else + rcExit = RTMsgErrorExitFailure("RTPathQueryInfo failed on '%s': %Rrc", szAbsSrc, vrc); + } + else + rcExit = RTMsgErrorExitFailure("RTPathAbs failed on '%s': %Rrc", pszSource, vrc); + } + else + { + /* + * Source guest, destination host. + */ + /* We need to query the source type on the guest first in order to know which copy flavor we need. */ + ComPtr<IGuestFsObjInfo> pFsObjInfo; + rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszSource).raw(), TRUE /* fFollowSymlinks */, pFsObjInfo.asOutParam()); + if (SUCCEEDED(rc)) + { + FsObjType_T enmObjType; + CHECK_ERROR(pFsObjInfo,COMGETTER(Type)(&enmObjType)); + if (SUCCEEDED(rc)) + { + /* Take action according to source file. */ + if (enmObjType == FsObjType_Directory) + { + if (pCtx->cVerbose) + RTPrintf("Directory '%s' -> '%s'\n", pszSource, pszDst); + + SafeArray<DirectoryCopyFlag_T> aCopyFlags; + aCopyFlags.push_back(DirectoryCopyFlag_CopyIntoExisting); + rc = pCtx->pGuestSession->DirectoryCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(), + ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam()); + } + else if (enmObjType == FsObjType_File) + { + if (pCtx->cVerbose) + RTPrintf("File '%s' -> '%s'\n", pszSource, pszDst); + + SafeArray<FileCopyFlag_T> aCopyFlags; + rc = pCtx->pGuestSession->FileCopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDst).raw(), + ComSafeArrayAsInParam(aCopyFlags), pProgress.asOutParam()); + } + else + rcExit = RTMsgErrorExitFailure("Not a file or directory: %s\n", pszSource); + } + else + rcExit = RTEXITCODE_FAILURE; + } + else + rcExit = RTMsgErrorExitFailure("FsObjQueryInfo failed on '%s': %Rhrc", pszSource, rc); + } + } + + if (FAILED(rc)) + { + vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession)); + } + else if (pProgress.isNotNull()) + { + if (pCtx->cVerbose) + rc = showProgress(pProgress); + else + rc = pProgress->WaitForCompletion(-1 /* No timeout */); + if (SUCCEEDED(rc)) + CHECK_PROGRESS_ERROR(pProgress, ("File copy failed")); + vrc = gctlPrintProgressError(pProgress); + } + if (RT_FAILURE(vrc)) + rcExit = RTEXITCODE_FAILURE; + + return rcExit; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleCopyFrom(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + return gctlHandleCopy(pCtx, argc, argv, false /* Guest to host */); +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleCopyTo(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + return gctlHandleCopy(pCtx, argc, argv, true /* Host to guest */); +} + +static DECLCALLBACK(RTEXITCODE) gctrlHandleMkDir(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--mode", 'm', RTGETOPT_REQ_UINT32 }, + { "--parents", 'P', RTGETOPT_REQ_NOTHING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + SafeArray<DirectoryCreateFlag_T> aDirCreateFlags; + uint32_t fDirMode = 0; /* Default mode. */ + uint32_t cDirsCreated = 0; + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'm': /* Mode */ + fDirMode = ValueUnion.u32; + break; + + case 'P': /* Create parents */ + aDirCreateFlags.push_back(DirectoryCreateFlag_Parents); + break; + + case VINF_GETOPT_NOT_OPTION: + if (cDirsCreated == 0) + { + /* + * First non-option - no more options now. + */ + rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + if (pCtx->cVerbose) + RTPrintf("Creating %RU32 directories...\n", argc - GetState.iNext + 1); + } + if (g_fGuestCtrlCanceled) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "mkdir was interrupted by Ctrl-C (%u left)\n", + argc - GetState.iNext + 1); + + /* + * Create the specified directory. + * + * On failure we'll change the exit status to failure and + * continue with the next directory that needs creating. We do + * this because we only create new things, and because this is + * how /bin/mkdir works on unix. + */ + cDirsCreated++; + if (pCtx->cVerbose) + RTPrintf("Creating directory \"%s\" ...\n", ValueUnion.psz); + try + { + HRESULT rc; + CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(), + fDirMode, ComSafeArrayAsInParam(aDirCreateFlags))); + if (FAILED(rc)) + rcExit = RTEXITCODE_FAILURE; + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n"); + } + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, ch, &ValueUnion); + } + } + + if (!cDirsCreated) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, "No directory to create specified!"); + return rcExit; +} + + +static DECLCALLBACK(RTEXITCODE) gctlHandleRmDir(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--recursive", 'R', RTGETOPT_REQ_NOTHING }, + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + bool fRecursive = false; + uint32_t cDirRemoved = 0; + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'R': + fRecursive = true; + break; + + case VINF_GETOPT_NOT_OPTION: + { + if (cDirRemoved == 0) + { + /* + * First non-option - no more options now. + */ + rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + if (pCtx->cVerbose) + RTPrintf("Removing %RU32 directorie%s(s)...\n", argc - GetState.iNext + 1, fRecursive ? "tree" : ""); + } + if (g_fGuestCtrlCanceled) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "rmdir was interrupted by Ctrl-C (%u left)\n", + argc - GetState.iNext + 1); + + cDirRemoved++; + HRESULT rc; + if (!fRecursive) + { + /* + * Remove exactly one directory. + */ + if (pCtx->cVerbose) + RTPrintf("Removing directory \"%s\" ...\n", ValueUnion.psz); + try + { + CHECK_ERROR(pCtx->pGuestSession, DirectoryRemove(Bstr(ValueUnion.psz).raw())); + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n"); + } + } + else + { + /* + * Remove the directory and anything under it, that means files + * and everything. This is in the tradition of the Windows NT + * CMD.EXE "rmdir /s" operation, a tradition which jpsoft's TCC + * strongly warns against (and half-ways questions the sense of). + */ + if (pCtx->cVerbose) + RTPrintf("Recursively removing directory \"%s\" ...\n", ValueUnion.psz); + try + { + /** @todo Make flags configurable. */ + com::SafeArray<DirectoryRemoveRecFlag_T> aRemRecFlags; + aRemRecFlags.push_back(DirectoryRemoveRecFlag_ContentAndDir); + + ComPtr<IProgress> ptrProgress; + CHECK_ERROR(pCtx->pGuestSession, DirectoryRemoveRecursive(Bstr(ValueUnion.psz).raw(), + ComSafeArrayAsInParam(aRemRecFlags), + ptrProgress.asOutParam())); + if (SUCCEEDED(rc)) + { + if (pCtx->cVerbose) + rc = showProgress(ptrProgress); + else + rc = ptrProgress->WaitForCompletion(-1 /* indefinitely */); + if (SUCCEEDED(rc)) + CHECK_PROGRESS_ERROR(ptrProgress, ("Directory deletion failed")); + ptrProgress.setNull(); + } + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory during recursive rmdir\n"); + } + } + + /* + * This command returns immediately on failure since it's destructive in nature. + */ + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + break; + } + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, ch, &ValueUnion); + } + } + + if (!cDirRemoved) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, "No directory to remove specified!"); + return rcExit; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleRm(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--force", 'f', RTGETOPT_REQ_NOTHING, }, + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + uint32_t cFilesDeleted = 0; + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + bool fForce = true; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case VINF_GETOPT_NOT_OPTION: + if (cFilesDeleted == 0) + { + /* + * First non-option - no more options now. + */ + rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + if (pCtx->cVerbose) + RTPrintf("Removing %RU32 file(s)...\n", argc - GetState.iNext + 1); + } + if (g_fGuestCtrlCanceled) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "rm was interrupted by Ctrl-C (%u left)\n", + argc - GetState.iNext + 1); + + /* + * Remove the specified file. + * + * On failure we will by default stop, however, the force option will + * by unix traditions force us to ignore errors and continue. + */ + cFilesDeleted++; + if (pCtx->cVerbose) + RTPrintf("Removing file \"%s\" ...\n", ValueUnion.psz); + try + { + /** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we + * need to do some chmod or whatever to better emulate the --force flag? */ + HRESULT rc; + CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw())); + if (FAILED(rc) && !fForce) + return RTEXITCODE_FAILURE; + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n"); + } + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, ch, &ValueUnion); + } + } + + if (!cFilesDeleted && !fForce) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, "No file to remove specified!"); + return rcExit; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleMv(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() +/** @todo Missing --force/-f flag. */ + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + int vrc = VINF_SUCCESS; + + bool fDryrun = false; + std::vector< Utf8Str > vecSources; + const char *pszDst = NULL; + com::SafeArray<FsObjRenameFlag_T> aRenameFlags; + + try + { + /** @todo Make flags configurable. */ + aRenameFlags.push_back(FsObjRenameFlag_NoReplace); + + while ( (ch = RTGetOpt(&GetState, &ValueUnion)) + && RT_SUCCESS(vrc)) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + /** @todo Implement a --dryrun command. */ + /** @todo Implement rename flags. */ + + case VINF_GETOPT_NOT_OPTION: + vecSources.push_back(Utf8Str(ValueUnion.psz)); + pszDst = ValueUnion.psz; + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV, ch, &ValueUnion); + } + } + } + catch (std::bad_alloc &) + { + vrc = VERR_NO_MEMORY; + } + + if (RT_FAILURE(vrc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize, rc=%Rrc\n", vrc); + + size_t cSources = vecSources.size(); + if (!cSources) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV, + "No source(s) to move specified!"); + if (cSources < 2) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV, + "No destination specified!"); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + /* Delete last element, which now is the destination. */ + vecSources.pop_back(); + cSources = vecSources.size(); + + HRESULT rc = S_OK; + + if (cSources > 1) + { + BOOL fExists = FALSE; + rc = pCtx->pGuestSession->DirectoryExists(Bstr(pszDst).raw(), FALSE /*followSymlinks*/, &fExists); + if (FAILED(rc) || !fExists) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Destination must be a directory when specifying multiple sources\n"); + } + + /* + * Rename (move) the entries. + */ + if (pCtx->cVerbose) + RTPrintf("Renaming %RU32 %s ...\n", cSources, cSources > 1 ? "entries" : "entry"); + + std::vector< Utf8Str >::iterator it = vecSources.begin(); + while ( it != vecSources.end() + && !g_fGuestCtrlCanceled) + { + Utf8Str strCurSource = (*it); + + ComPtr<IGuestFsObjInfo> pFsObjInfo; + FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */ + rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strCurSource).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam()); + if (SUCCEEDED(rc)) + rc = pFsObjInfo->COMGETTER(Type)(&enmObjType); + if (FAILED(rc)) + { + if (pCtx->cVerbose) + RTPrintf("Warning: Cannot stat for element \"%s\": No such file or directory\n", strCurSource.c_str()); + ++it; + continue; /* Skip. */ + } + + if (pCtx->cVerbose) + RTPrintf("Renaming %s \"%s\" to \"%s\" ...\n", + enmObjType == FsObjType_Directory ? "directory" : "file", + strCurSource.c_str(), pszDst); + + if (!fDryrun) + { + if (enmObjType == FsObjType_Directory) + { + CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(), + Bstr(pszDst).raw(), + ComSafeArrayAsInParam(aRenameFlags))); + + /* Break here, since it makes no sense to rename mroe than one source to + * the same directory. */ +/** @todo r=bird: You are being kind of windowsy (or just DOSish) about the 'sense' part here, + * while being totaly buggy about the behavior. 'VBoxManage guestcontrol ren dir1 dir2 dstdir' will + * stop after 'dir1' and SILENTLY ignore dir2. If you tried this on Windows, you'd see an error + * being displayed. If you 'man mv' on a nearby unixy system, you'd see that they've made perfect + * sense out of any situation with more than one source. */ + it = vecSources.end(); + break; + } + else + CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(), + Bstr(pszDst).raw(), + ComSafeArrayAsInParam(aRenameFlags))); + } + + ++it; + } + + if ( (it != vecSources.end()) + && pCtx->cVerbose) + { + RTPrintf("Warning: Not all sources were renamed\n"); + } + + return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleMkTemp(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--mode", 'm', RTGETOPT_REQ_UINT32 }, + { "--directory", 'D', RTGETOPT_REQ_NOTHING }, + { "--secure", 's', RTGETOPT_REQ_NOTHING }, + { "--tmpdir", 't', RTGETOPT_REQ_STRING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + Utf8Str strTemplate; + uint32_t fMode = 0; /* Default mode. */ + bool fDirectory = false; + bool fSecure = false; + Utf8Str strTempDir; + + DESTDIRMAP mapDirs; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'm': /* Mode */ + fMode = ValueUnion.u32; + break; + + case 'D': /* Create directory */ + fDirectory = true; + break; + + case 's': /* Secure */ + fSecure = true; + break; + + case 't': /* Temp directory */ + strTempDir = ValueUnion.psz; + break; + + case VINF_GETOPT_NOT_OPTION: + if (strTemplate.isEmpty()) + strTemplate = ValueUnion.psz; + else + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, + "More than one template specified!\n"); + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, ch, &ValueUnion); + } + } + + if (strTemplate.isEmpty()) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, + "No template specified!"); + + if (!fDirectory) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, + "Creating temporary files is currently not supported!"); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + /* + * Create the directories. + */ + if (pCtx->cVerbose) + { + if (fDirectory && !strTempDir.isEmpty()) + RTPrintf("Creating temporary directory from template '%s' in directory '%s' ...\n", + strTemplate.c_str(), strTempDir.c_str()); + else if (fDirectory) + RTPrintf("Creating temporary directory from template '%s' in default temporary directory ...\n", + strTemplate.c_str()); + else if (!fDirectory && !strTempDir.isEmpty()) + RTPrintf("Creating temporary file from template '%s' in directory '%s' ...\n", + strTemplate.c_str(), strTempDir.c_str()); + else if (!fDirectory) + RTPrintf("Creating temporary file from template '%s' in default temporary directory ...\n", + strTemplate.c_str()); + } + + HRESULT rc = S_OK; + if (fDirectory) + { + Bstr bstrDirectory; + CHECK_ERROR(pCtx->pGuestSession, DirectoryCreateTemp(Bstr(strTemplate).raw(), + fMode, Bstr(strTempDir).raw(), + fSecure, + bstrDirectory.asOutParam())); + if (SUCCEEDED(rc)) + RTPrintf("Directory name: %ls\n", bstrDirectory.raw()); + } + else + { + // else - temporary file not yet implemented + /** @todo implement temporary file creation (we fend it off above, no + * worries). */ + rc = E_FAIL; + } + + return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleStat(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--dereference", 'L', RTGETOPT_REQ_NOTHING }, + { "--file-system", 'f', RTGETOPT_REQ_NOTHING }, + { "--format", 'c', RTGETOPT_REQ_STRING }, + { "--terse", 't', RTGETOPT_REQ_NOTHING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0 + && ch != VINF_GETOPT_NOT_OPTION) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'L': /* Dereference */ + case 'f': /* File-system */ + case 'c': /* Format */ + case 't': /* Terse */ + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT, + "Command \"%s\" not implemented yet!", ValueUnion.psz); + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT, ch, &ValueUnion); + } + } + + if (ch != VINF_GETOPT_NOT_OPTION) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT, "Nothing to stat!"); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + + /* + * Do the file stat'ing. + */ + while (ch == VINF_GETOPT_NOT_OPTION) + { + if (pCtx->cVerbose) + RTPrintf("Checking for element \"%s\" ...\n", ValueUnion.psz); + + ComPtr<IGuestFsObjInfo> pFsObjInfo; + HRESULT hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(ValueUnion.psz).raw(), FALSE /*followSymlinks*/, + pFsObjInfo.asOutParam()); + if (FAILED(hrc)) + { + /** @todo r=bird: There might be other reasons why we end up here than + * non-existing "element" (object or file, please, nobody calls it elements). */ + if (pCtx->cVerbose) + RTPrintf("Failed to stat '%s': No such file\n", ValueUnion.psz); + rcExit = RTEXITCODE_FAILURE; + } + else + { + RTPrintf(" File: '%s'\n", ValueUnion.psz); /** @todo escape this name. */ + + FsObjType_T enmType = FsObjType_Unknown; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(Type)(&enmType)); + LONG64 cbObject = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(ObjectSize)(&cbObject)); + LONG64 cbAllocated = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(AllocatedSize)(&cbAllocated)); + LONG uid = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(UID)(&uid)); + LONG gid = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(GID)(&gid)); + Bstr bstrUsername; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(UserName)(bstrUsername.asOutParam())); + Bstr bstrGroupName; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(GroupName)(bstrGroupName.asOutParam())); + Bstr bstrAttribs; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(FileAttributes)(bstrAttribs.asOutParam())); + LONG64 idNode = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeId)(&idNode)); + ULONG uDevNode = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeIdDevice)(&uDevNode)); + ULONG uDeviceNo = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(DeviceNumber)(&uDeviceNo)); + ULONG cHardLinks = 1; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(HardLinks)(&cHardLinks)); + LONG64 nsBirthTime = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(BirthTime)(&nsBirthTime)); + LONG64 nsChangeTime = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(ChangeTime)(&nsChangeTime)); + LONG64 nsModificationTime = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(ModificationTime)(&nsModificationTime)); + LONG64 nsAccessTime = 0; + CHECK_ERROR2I(pFsObjInfo, COMGETTER(AccessTime)(&nsAccessTime)); + + RTPrintf(" Size: %-17RU64 Alloc: %-19RU64 Type: %s\n", cbObject, cbAllocated, gctlFsObjTypeToName(enmType)); + RTPrintf("Device: %#-17RX32 INode: %-18RU64 Links: %u\n", uDevNode, idNode, cHardLinks); + + Utf8Str strAttrib(bstrAttribs); + char *pszMode = strAttrib.mutableRaw(); + char *pszAttribs = strchr(pszMode, ' '); + if (pszAttribs) + do *pszAttribs++ = '\0'; + while (*pszAttribs == ' '); + else + pszAttribs = strchr(pszMode, '\0'); + if (uDeviceNo != 0) + RTPrintf(" Mode: %-16s Attrib: %-17s Dev ID: %#RX32\n", pszMode, pszAttribs, uDeviceNo); + else + RTPrintf(" Mode: %-16s Attrib: %s\n", pszMode, pszAttribs); + + RTPrintf(" Owner: %4d/%-12ls Group: %4d/%ls\n", uid, bstrUsername.raw(), gid, bstrGroupName.raw()); + + RTTIMESPEC TimeSpec; + char szTmp[RTTIME_STR_LEN]; + RTPrintf(" Birth: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsBirthTime), szTmp, sizeof(szTmp))); + RTPrintf("Change: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsChangeTime), szTmp, sizeof(szTmp))); + RTPrintf("Modify: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsModificationTime), szTmp, sizeof(szTmp))); + RTPrintf("Access: %s\n", RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsAccessTime), szTmp, sizeof(szTmp))); + + /* Skiping: Generation ID - only the ISO9660 VFS sets this. FreeBSD user flags. */ + } + + /* Next file. */ + ch = RTGetOpt(&GetState, &ValueUnion); + } + + return rcExit; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleUpdateAdditions(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + /* + * Check the syntax. We can deduce the correct syntax from the number of + * arguments. + */ + Utf8Str strSource; + com::SafeArray<IN_BSTR> aArgs; + bool fWaitStartOnly = false; + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--source", 's', RTGETOPT_REQ_STRING }, + { "--wait-start", 'w', RTGETOPT_REQ_NOTHING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + int vrc = VINF_SUCCESS; + while ( (ch = RTGetOpt(&GetState, &ValueUnion)) + && RT_SUCCESS(vrc)) + { + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 's': + strSource = ValueUnion.psz; + break; + + case 'w': + fWaitStartOnly = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (aArgs.size() == 0 && strSource.isEmpty()) + strSource = ValueUnion.psz; + else + aArgs.push_back(Bstr(ValueUnion.psz).raw()); + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion); + } + } + + if (pCtx->cVerbose) + RTPrintf("Updating Guest Additions ...\n"); + + HRESULT rc = S_OK; + while (strSource.isEmpty()) + { + ComPtr<ISystemProperties> pProperties; + CHECK_ERROR_BREAK(pCtx->pArg->virtualBox, COMGETTER(SystemProperties)(pProperties.asOutParam())); + Bstr strISO; + CHECK_ERROR_BREAK(pProperties, COMGETTER(DefaultAdditionsISO)(strISO.asOutParam())); + strSource = strISO; + break; + } + + /* Determine source if not set yet. */ + if (strSource.isEmpty()) + { + RTMsgError("No Guest Additions source found or specified, aborting\n"); + vrc = VERR_FILE_NOT_FOUND; + } + else if (!RTFileExists(strSource.c_str())) + { + RTMsgError("Source \"%s\" does not exist!\n", strSource.c_str()); + vrc = VERR_FILE_NOT_FOUND; + } + + if (RT_SUCCESS(vrc)) + { + if (pCtx->cVerbose) + RTPrintf("Using source: %s\n", strSource.c_str()); + + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + + com::SafeArray<AdditionsUpdateFlag_T> aUpdateFlags; + if (fWaitStartOnly) + { + aUpdateFlags.push_back(AdditionsUpdateFlag_WaitForUpdateStartOnly); + if (pCtx->cVerbose) + RTPrintf("Preparing and waiting for Guest Additions installer to start ...\n"); + } + + ComPtr<IProgress> pProgress; + CHECK_ERROR(pCtx->pGuest, UpdateGuestAdditions(Bstr(strSource).raw(), + ComSafeArrayAsInParam(aArgs), + /* Wait for whole update process to complete. */ + ComSafeArrayAsInParam(aUpdateFlags), + pProgress.asOutParam())); + if (FAILED(rc)) + vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest)); + else + { + if (pCtx->cVerbose) + rc = showProgress(pProgress); + else + rc = pProgress->WaitForCompletion(-1 /* No timeout */); + + if (SUCCEEDED(rc)) + CHECK_PROGRESS_ERROR(pProgress, ("Guest additions update failed")); + vrc = gctlPrintProgressError(pProgress); + if ( RT_SUCCESS(vrc) + && pCtx->cVerbose) + { + RTPrintf("Guest Additions update successful\n"); + } + } + } + + return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleList(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + bool fSeenListArg = false; + bool fListAll = false; + bool fListSessions = false; + bool fListProcesses = false; + bool fListFiles = false; + + int vrc = VINF_SUCCESS; + while ( (ch = RTGetOpt(&GetState, &ValueUnion)) + && RT_SUCCESS(vrc)) + { + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case VINF_GETOPT_NOT_OPTION: + if ( !RTStrICmp(ValueUnion.psz, "sessions") + || !RTStrICmp(ValueUnion.psz, "sess")) + fListSessions = true; + else if ( !RTStrICmp(ValueUnion.psz, "processes") + || !RTStrICmp(ValueUnion.psz, "procs")) + fListSessions = fListProcesses = true; /* Showing processes implies showing sessions. */ + else if (!RTStrICmp(ValueUnion.psz, "files")) + fListSessions = fListFiles = true; /* Showing files implies showing sessions. */ + else if (!RTStrICmp(ValueUnion.psz, "all")) + fListAll = true; + else + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST, + "Unknown list: '%s'", ValueUnion.psz); + fSeenListArg = true; + break; + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion); + } + } + + if (!fSeenListArg) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST, "Missing list name"); + Assert(fListAll || fListSessions); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + + /** @todo Do we need a machine-readable output here as well? */ + + HRESULT rc; + size_t cTotalProcs = 0; + size_t cTotalFiles = 0; + + SafeIfaceArray <IGuestSession> collSessions; + CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions))); + if (SUCCEEDED(rc)) + { + size_t const cSessions = collSessions.size(); + if (cSessions) + { + RTPrintf("Active guest sessions:\n"); + + /** @todo Make this output a bit prettier. No time now. */ + + for (size_t i = 0; i < cSessions; i++) + { + ComPtr<IGuestSession> pCurSession = collSessions[i]; + if (!pCurSession.isNull()) + { + do + { + ULONG uID; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(Id)(&uID)); + Bstr strName; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(Name)(strName.asOutParam())); + Bstr strUser; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(User)(strUser.asOutParam())); + GuestSessionStatus_T sessionStatus; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus)); + RTPrintf("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls", + i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw()); + } while (0); + + if ( fListAll + || fListProcesses) + { + SafeIfaceArray <IGuestProcess> collProcesses; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcesses))); + for (size_t a = 0; a < collProcesses.size(); a++) + { + ComPtr<IGuestProcess> pCurProcess = collProcesses[a]; + if (!pCurProcess.isNull()) + { + do + { + ULONG uPID; + CHECK_ERROR_BREAK(pCurProcess, COMGETTER(PID)(&uPID)); + Bstr strExecPath; + CHECK_ERROR_BREAK(pCurProcess, COMGETTER(ExecutablePath)(strExecPath.asOutParam())); + ProcessStatus_T procStatus; + CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus)); + + RTPrintf("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls", + a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw()); + } while (0); + } + } + + cTotalProcs += collProcesses.size(); + } + + if ( fListAll + || fListFiles) + { + SafeIfaceArray <IGuestFile> collFiles; + CHECK_ERROR_BREAK(pCurSession, COMGETTER(Files)(ComSafeArrayAsOutParam(collFiles))); + for (size_t a = 0; a < collFiles.size(); a++) + { + ComPtr<IGuestFile> pCurFile = collFiles[a]; + if (!pCurFile.isNull()) + { + do + { + ULONG idFile; + CHECK_ERROR_BREAK(pCurFile, COMGETTER(Id)(&idFile)); + Bstr strName; + CHECK_ERROR_BREAK(pCurFile, COMGETTER(Filename)(strName.asOutParam())); + FileStatus_T fileStatus; + CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus)); + + RTPrintf("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls", + a, idFile, gctlFileStatusToText(fileStatus), strName.raw()); + } while (0); + } + } + + cTotalFiles += collFiles.size(); + } + } + } + + RTPrintf("\n\nTotal guest sessions: %zu\n", collSessions.size()); + if (fListAll || fListProcesses) + RTPrintf("Total guest processes: %zu\n", cTotalProcs); + if (fListAll || fListFiles) + RTPrintf("Total guest files: %zu\n", cTotalFiles); + } + else + RTPrintf("No active guest sessions found\n"); + } + + if (FAILED(rc)) /** @todo yeah, right... Only the last error? */ + rcExit = RTEXITCODE_FAILURE; + + return rcExit; +} + +static DECLCALLBACK(RTEXITCODE) gctlHandleCloseProcess(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--session-id", 'i', RTGETOPT_REQ_UINT32 }, + { "--session-name", 'n', RTGETOPT_REQ_STRING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + std::vector < uint32_t > vecPID; + ULONG idSession = UINT32_MAX; + Utf8Str strSessionName; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'n': /* Session name (or pattern) */ + strSessionName = ValueUnion.psz; + break; + + case 'i': /* Session ID */ + idSession = ValueUnion.u32; + break; + + case VINF_GETOPT_NOT_OPTION: + { + /* Treat every else specified as a PID to kill. */ + uint32_t uPid; + int rc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid); + if ( RT_SUCCESS(rc) + && rc != VWRN_TRAILING_CHARS + && rc != VWRN_NUMBER_TOO_BIG + && rc != VWRN_NEGATIVE_UNSIGNED) + { + if (uPid != 0) + { + try + { + vecPID.push_back(uPid); + } + catch (std::bad_alloc &) + { + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory"); + } + } + else + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "Invalid PID value: 0"); + } + else + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "Error parsing PID value: %Rrc", rc); + break; + } + + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, ch, &ValueUnion); + } + } + + if (vecPID.empty()) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, + "At least one PID must be specified to kill!"); + + if ( strSessionName.isEmpty() + && idSession == UINT32_MAX) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "No session ID specified!"); + + if ( strSessionName.isNotEmpty() + && idSession != UINT32_MAX) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, + "Either session ID or name (pattern) must be specified"); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + HRESULT rc = S_OK; + + ComPtr<IGuestSession> pSession; + ComPtr<IGuestProcess> pProcess; + do + { + uint32_t uProcsTerminated = 0; + + SafeIfaceArray <IGuestSession> collSessions; + CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions))); + size_t cSessions = collSessions.size(); + + uint32_t cSessionsHandled = 0; + for (size_t i = 0; i < cSessions; i++) + { + pSession = collSessions[i]; + Assert(!pSession.isNull()); + + ULONG uID; /* Session ID */ + CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID)); + Bstr strName; + CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam())); + Utf8Str strNameUtf8(strName); /* Session name */ + + bool fSessionFound; + if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */ + fSessionFound = uID == idSession; + else /* ... or by naming pattern. */ + fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()); + if (fSessionFound) + { + AssertStmt(!pSession.isNull(), break); + cSessionsHandled++; + + SafeIfaceArray <IGuestProcess> collProcs; + CHECK_ERROR_BREAK(pSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcs))); + + size_t cProcs = collProcs.size(); + for (size_t p = 0; p < cProcs; p++) + { + pProcess = collProcs[p]; + Assert(!pProcess.isNull()); + + ULONG uPID; /* Process ID */ + CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID)); + + bool fProcFound = false; + for (size_t a = 0; a < vecPID.size(); a++) /* Slow, but works. */ + { + fProcFound = vecPID[a] == uPID; + if (fProcFound) + break; + } + + if (fProcFound) + { + if (pCtx->cVerbose) + RTPrintf("Terminating process (PID %RU32) (session ID %RU32) ...\n", + uPID, uID); + CHECK_ERROR_BREAK(pProcess, Terminate()); + uProcsTerminated++; + } + else + { + if (idSession != UINT32_MAX) + RTPrintf("No matching process(es) for session ID %RU32 found\n", + idSession); + } + + pProcess.setNull(); + } + + pSession.setNull(); + } + } + + if (!cSessionsHandled) + RTPrintf("No matching session(s) found\n"); + + if (uProcsTerminated) + RTPrintf("%RU32 %s terminated\n", + uProcsTerminated, uProcsTerminated == 1 ? "process" : "processes"); + + } while (0); + + pProcess.setNull(); + pSession.setNull(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +static DECLCALLBACK(RTEXITCODE) gctlHandleCloseSession(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + enum GETOPTDEF_SESSIONCLOSE + { + GETOPTDEF_SESSIONCLOSE_ALL = 2000 + }; + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + { "--all", GETOPTDEF_SESSIONCLOSE_ALL, RTGETOPT_REQ_NOTHING }, + { "--session-id", 'i', RTGETOPT_REQ_UINT32 }, + { "--session-name", 'n', RTGETOPT_REQ_STRING } + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + ULONG idSession = UINT32_MAX; + Utf8Str strSessionName; + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case 'n': /* Session name pattern */ + strSessionName = ValueUnion.psz; + break; + + case 'i': /* Session ID */ + idSession = ValueUnion.u32; + break; + + case GETOPTDEF_SESSIONCLOSE_ALL: + strSessionName = "*"; + break; + + case VINF_GETOPT_NOT_OPTION: + /** @todo Supply a CSV list of IDs or patterns to close? + * break; */ + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION, ch, &ValueUnion); + } + } + + if ( strSessionName.isEmpty() + && idSession == UINT32_MAX) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION, + "No session ID specified!"); + + if ( !strSessionName.isEmpty() + && idSession != UINT32_MAX) + return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION, + "Either session ID or name (pattern) must be specified"); + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + HRESULT rc = S_OK; + + do + { + size_t cSessionsHandled = 0; + + SafeIfaceArray <IGuestSession> collSessions; + CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions))); + size_t cSessions = collSessions.size(); + + for (size_t i = 0; i < cSessions; i++) + { + ComPtr<IGuestSession> pSession = collSessions[i]; + Assert(!pSession.isNull()); + + ULONG uID; /* Session ID */ + CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID)); + Bstr strName; + CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam())); + Utf8Str strNameUtf8(strName); /* Session name */ + + bool fSessionFound; + if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */ + fSessionFound = uID == idSession; + else /* ... or by naming pattern. */ + fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()); + if (fSessionFound) + { + cSessionsHandled++; + + Assert(!pSession.isNull()); + if (pCtx->cVerbose) + RTPrintf("Closing guest session ID=#%RU32 \"%s\" ...\n", + uID, strNameUtf8.c_str()); + CHECK_ERROR_BREAK(pSession, Close()); + if (pCtx->cVerbose) + RTPrintf("Guest session successfully closed\n"); + + pSession.setNull(); + } + } + + if (!cSessionsHandled) + { + RTPrintf("No guest session(s) found\n"); + rc = E_ABORT; /* To set exit code accordingly. */ + } + + } while (0); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +static DECLCALLBACK(RTEXITCODE) gctlHandleWatch(PGCTLCMDCTX pCtx, int argc, char **argv) +{ + AssertPtrReturn(pCtx, RTEXITCODE_FAILURE); + + /* + * Parse arguments. + */ + static const RTGETOPTDEF s_aOptions[] = + { + GCTLCMD_COMMON_OPTION_DEFS() + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + /* For options that require an argument, ValueUnion has received the value. */ + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion); + + case VINF_GETOPT_NOT_OPTION: + default: + return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_WATCH, ch, &ValueUnion); + } + } + + /** @todo Specify categories to watch for. */ + /** @todo Specify a --timeout for waiting only for a certain amount of time? */ + + RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + + HRESULT rc; + + try + { + ComObjPtr<GuestEventListenerImpl> pGuestListener; + do + { + /* Listener creation. */ + pGuestListener.createObject(); + pGuestListener->init(new GuestEventListener()); + + /* Register for IGuest events. */ + ComPtr<IEventSource> es; + CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam())); + com::SafeArray<VBoxEventType_T> eventTypes; + eventTypes.push_back(VBoxEventType_OnGuestSessionRegistered); + /** @todo Also register for VBoxEventType_OnGuestUserStateChanged on demand? */ + CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes), + true /* Active listener */)); + /* Note: All other guest control events have to be registered + * as their corresponding objects appear. */ + + } while (0); + + if (pCtx->cVerbose) + RTPrintf("Waiting for events ...\n"); + +/** @todo r=bird: This are-we-there-yet approach to things could easily be + * replaced by a global event semaphore that gets signalled from the + * signal handler and the callback event. Please fix! */ + while (!g_fGuestCtrlCanceled) + { + /** @todo Timeout handling (see above)? */ + RTThreadSleep(10); + } + + if (pCtx->cVerbose) + RTPrintf("Signal caught, exiting ...\n"); + + if (!pGuestListener.isNull()) + { + /* Guest callback unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR(pES, UnregisterListener(pGuestListener)); + pGuestListener.setNull(); + } + } + catch (std::bad_alloc &) + { + rc = E_OUTOFMEMORY; + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +/** + * Access the guest control store. + * + * @returns program exit code. + * @note see the command line API description for parameters + */ +RTEXITCODE handleGuestControl(HandlerArg *pArg) +{ + AssertPtr(pArg); + +#ifdef DEBUG_andy_disabled + if (RT_FAILURE(tstTranslatePath())) + return RTEXITCODE_FAILURE; +#endif + + /* + * Command definitions. + */ + static const GCTLCMDDEF s_aCmdDefs[] = + { + { "run", gctlHandleRun, USAGE_GSTCTRL_RUN, 0, }, + { "start", gctlHandleStart, USAGE_GSTCTRL_START, 0, }, + { "copyfrom", gctlHandleCopyFrom, USAGE_GSTCTRL_COPYFROM, 0, }, + { "copyto", gctlHandleCopyTo, USAGE_GSTCTRL_COPYTO, 0, }, + + { "mkdir", gctrlHandleMkDir, USAGE_GSTCTRL_MKDIR, 0, }, + { "md", gctrlHandleMkDir, USAGE_GSTCTRL_MKDIR, 0, }, + { "createdirectory", gctrlHandleMkDir, USAGE_GSTCTRL_MKDIR, 0, }, + { "createdir", gctrlHandleMkDir, USAGE_GSTCTRL_MKDIR, 0, }, + + { "rmdir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, }, + { "removedir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, }, + { "removedirectory", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, }, + + { "rm", gctlHandleRm, USAGE_GSTCTRL_RM, 0, }, + { "removefile", gctlHandleRm, USAGE_GSTCTRL_RM, 0, }, + { "erase", gctlHandleRm, USAGE_GSTCTRL_RM, 0, }, + { "del", gctlHandleRm, USAGE_GSTCTRL_RM, 0, }, + { "delete", gctlHandleRm, USAGE_GSTCTRL_RM, 0, }, + + { "mv", gctlHandleMv, USAGE_GSTCTRL_MV, 0, }, + { "move", gctlHandleMv, USAGE_GSTCTRL_MV, 0, }, + { "ren", gctlHandleMv, USAGE_GSTCTRL_MV, 0, }, + { "rename", gctlHandleMv, USAGE_GSTCTRL_MV, 0, }, + + { "mktemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, }, + { "createtemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, }, + { "createtemporary", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, }, + + { "stat", gctlHandleStat, USAGE_GSTCTRL_STAT, 0, }, + + { "closeprocess", gctlHandleCloseProcess, USAGE_GSTCTRL_CLOSEPROCESS, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + { "closesession", gctlHandleCloseSession, USAGE_GSTCTRL_CLOSESESSION, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + { "list", gctlHandleList, USAGE_GSTCTRL_LIST, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + { "watch", gctlHandleWatch, USAGE_GSTCTRL_WATCH, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + + {"updateguestadditions",gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + { "updateadditions", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + { "updatega", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER, }, + }; + + /* + * VBoxManage guestcontrol [common-options] <VM> [common-options] <sub-command> ... + * + * Parse common options and VM name until we find a sub-command. Allowing + * the user to put the user and password related options before the + * sub-command makes it easier to edit the command line when doing several + * operations with the same guest user account. (Accidentally, it also + * makes the syntax diagram shorter and easier to read.) + */ + GCTLCMDCTX CmdCtx; + RTEXITCODE rcExit = gctrCmdCtxInit(&CmdCtx, pArg); + if (rcExit == RTEXITCODE_SUCCESS) + { + static const RTGETOPTDEF s_CommonOptions[] = { GCTLCMD_COMMON_OPTION_DEFS() }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0, 0 /* No sorting! */); + + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (ch) + { + GCTLCMD_COMMON_OPTION_CASES(&CmdCtx, ch, &ValueUnion); + + case VINF_GETOPT_NOT_OPTION: + /* First comes the VM name or UUID. */ + if (!CmdCtx.pszVmNameOrUuid) + CmdCtx.pszVmNameOrUuid = ValueUnion.psz; + /* + * The sub-command is next. Look it up and invoke it. + * Note! Currently no warnings about user/password options (like we'll do later on) + * for GCTLCMDCTX_F_SESSION_ANONYMOUS commands. No reason to be too pedantic. + */ + else + { + const char *pszCmd = ValueUnion.psz; + uint32_t iCmd; + for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++) + if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0) + { + CmdCtx.pCmdDef = &s_aCmdDefs[iCmd]; + + rcExit = s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1, + &pArg->argv[GetState.iNext - 1]); + + gctlCtxTerm(&CmdCtx); + return rcExit; + } + return errorSyntax(USAGE_GUESTCONTROL, "Unknown sub-command: '%s'", pszCmd); + } + break; + + default: + return errorGetOpt(USAGE_GUESTCONTROL, ch, &ValueUnion); + } + } + if (CmdCtx.pszVmNameOrUuid) + rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing sub-command"); + else + rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing VM name and sub-command"); + } + return rcExit; +} +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.h b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.h new file mode 100644 index 00000000..016fa548 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.h @@ -0,0 +1,236 @@ +/* $Id: VBoxManageGuestCtrl.h $ */ +/** @file + * VBoxManageGuestCtrl.h - Definitions for guest control. + */ + +/* + * Copyright (C) 2013-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxManage_VBoxManageGuestCtrl_h +#define VBOX_INCLUDED_SRC_VBoxManage_VBoxManageGuestCtrl_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#ifndef VBOX_ONLY_DOCS + +#include <VBox/com/com.h> +#include <VBox/com/listeners.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/time.h> + +#include <map> + +const char *gctlFileStatusToText(FileStatus_T enmStatus); +const char *gctlProcessStatusToText(ProcessStatus_T enmStatus); +const char *gctlGuestSessionStatusToText(GuestSessionStatus_T enmStatus); + +using namespace com; + +class GuestFileEventListener; +typedef ListenerImpl<GuestFileEventListener> GuestFileEventListenerImpl; + +class GuestProcessEventListener; +typedef ListenerImpl<GuestProcessEventListener> GuestProcessEventListenerImpl; + +class GuestSessionEventListener; +typedef ListenerImpl<GuestSessionEventListener> GuestSessionEventListenerImpl; + +class GuestEventListener; +typedef ListenerImpl<GuestEventListener> GuestEventListenerImpl; + +/** Simple statistics class for binding locally + * held data to a specific guest object. */ +class GuestEventStats +{ + +public: + + GuestEventStats(void) + : uLastUpdatedMS(RTTimeMilliTS()) + { + } + + /** @todo Make this more a class than a structure. */ +public: + + uint64_t uLastUpdatedMS; +}; + +class GuestFileStats : public GuestEventStats +{ + +public: + + GuestFileStats(void) { } + + GuestFileStats(ComObjPtr<GuestFileEventListenerImpl> pListenerImpl) + : mListener(pListenerImpl) + { + } + +public: /** @todo */ + + ComObjPtr<GuestFileEventListenerImpl> mListener; +}; + +class GuestProcStats : public GuestEventStats +{ + +public: + + GuestProcStats(void) { } + + GuestProcStats(ComObjPtr<GuestProcessEventListenerImpl> pListenerImpl) + : mListener(pListenerImpl) + { + } + +public: /** @todo */ + + ComObjPtr<GuestProcessEventListenerImpl> mListener; +}; + +class GuestSessionStats : public GuestEventStats +{ + +public: + + GuestSessionStats(void) { } + + GuestSessionStats(ComObjPtr<GuestSessionEventListenerImpl> pListenerImpl) + : mListener(pListenerImpl) + { + } + +public: /** @todo */ + + ComObjPtr<GuestSessionEventListenerImpl> mListener; +}; + +/** Map containing all watched guest files. */ +typedef std::map< ComPtr<IGuestFile>, GuestFileStats > GuestEventFiles; +/** Map containing all watched guest processes. */ +typedef std::map< ComPtr<IGuestProcess>, GuestProcStats > GuestEventProcs; +/** Map containing all watched guest sessions. */ +typedef std::map< ComPtr<IGuestSession>, GuestSessionStats > GuestEventSessions; + +class GuestListenerBase +{ +public: + + GuestListenerBase(void); + + virtual ~GuestListenerBase(void); + +public: + + HRESULT init(bool fVerbose = false); + +protected: + + /** Verbose flag. */ + bool mfVerbose; +}; + +/** + * Handler for guest process events. + */ +class GuestFileEventListener : public GuestListenerBase +{ +public: + + GuestFileEventListener(void); + + virtual ~GuestFileEventListener(void); + +public: + + void uninit(void); + + STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent); + +protected: + +}; + +/** + * Handler for guest process events. + */ +class GuestProcessEventListener : public GuestListenerBase +{ +public: + + GuestProcessEventListener(void); + + virtual ~GuestProcessEventListener(void); + +public: + + void uninit(void); + + STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent); + +protected: + +}; + +/** + * Handler for guest session events. + */ +class GuestSessionEventListener : public GuestListenerBase +{ +public: + + GuestSessionEventListener(void); + + virtual ~GuestSessionEventListener(void); + +public: + + void uninit(void); + + STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent); + +protected: + + GuestEventFiles mFiles; + GuestEventProcs mProcs; +}; + +/** + * Handler for guest events. + */ +class GuestEventListener : public GuestListenerBase +{ + +public: + + GuestEventListener(void); + + virtual ~GuestEventListener(void); + +public: + + void uninit(void); + + STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent); + +protected: + + GuestEventSessions mSessions; +}; +#endif /* !VBOX_ONLY_DOCS */ + +#endif /* !VBOX_INCLUDED_SRC_VBoxManage_VBoxManageGuestCtrl_h */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp new file mode 100644 index 00000000..20603474 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp @@ -0,0 +1,518 @@ +/* $Id: VBoxManageGuestCtrlListener.cpp $ */ +/** @file + * VBoxManage - Guest control listener implementations. + */ + +/* + * Copyright (C) 2013-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxManage.h" +#include "VBoxManageGuestCtrl.h" + +#ifndef VBOX_ONLY_DOCS + +#include <VBox/com/com.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> + +#include <iprt/time.h> + +#include <map> +#include <vector> + + + +/* + * GuestListenerBase + * GuestListenerBase + * GuestListenerBase + */ + +GuestListenerBase::GuestListenerBase(void) + : mfVerbose(false) +{ +} + +GuestListenerBase::~GuestListenerBase(void) +{ +} + +HRESULT GuestListenerBase::init(bool fVerbose) +{ + mfVerbose = fVerbose; + return S_OK; +} + + + +/* + * GuestFileEventListener + * GuestFileEventListener + * GuestFileEventListener + */ + +GuestFileEventListener::GuestFileEventListener(void) +{ +} + +GuestFileEventListener::~GuestFileEventListener(void) +{ +} + +void GuestFileEventListener::uninit(void) +{ + +} + +STDMETHODIMP GuestFileEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent) +{ + switch (aType) + { + case VBoxEventType_OnGuestFileStateChanged: + { + HRESULT rc; + do + { + ComPtr<IGuestFileStateChangedEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + + ComPtr<IGuestFile> pProcess; + CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pProcess.asOutParam())); + AssertBreak(!pProcess.isNull()); + FileStatus_T fileSts; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Status)(&fileSts)); + Bstr strPath; + CHECK_ERROR_BREAK(pProcess, COMGETTER(Filename)(strPath.asOutParam())); + ULONG uID; + CHECK_ERROR_BREAK(pProcess, COMGETTER(Id)(&uID)); + + RTPrintf("File ID=%RU32 \"%s\" changed status to [%s]\n", + uID, Utf8Str(strPath).c_str(), gctlFileStatusToText(fileSts)); + + } while (0); + break; + } + + default: + AssertFailed(); + } + + return S_OK; +} + + +/* + * GuestProcessEventListener + * GuestProcessEventListener + * GuestProcessEventListener + */ + +GuestProcessEventListener::GuestProcessEventListener(void) +{ +} + +GuestProcessEventListener::~GuestProcessEventListener(void) +{ +} + +void GuestProcessEventListener::uninit(void) +{ + +} + +STDMETHODIMP GuestProcessEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent) +{ + switch (aType) + { + case VBoxEventType_OnGuestProcessStateChanged: + { + HRESULT rc; + do + { + ComPtr<IGuestProcessStateChangedEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + + ComPtr<IGuestProcess> pProcess; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Process)(pProcess.asOutParam())); + AssertBreak(!pProcess.isNull()); + ProcessStatus_T procSts; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Status)(&procSts)); + Bstr strPath; + CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam())); + ULONG uPID; + CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID)); + + RTPrintf("Process PID=%RU32 \"%s\" changed status to [%s]\n", + uPID, Utf8Str(strPath).c_str(), gctlProcessStatusToText(procSts)); + + } while (0); + break; + } + + default: + AssertFailed(); + } + + return S_OK; +} + + +/* + * GuestSessionEventListener + * GuestSessionEventListener + * GuestSessionEventListener + */ + +GuestSessionEventListener::GuestSessionEventListener(void) +{ +} + +GuestSessionEventListener::~GuestSessionEventListener(void) +{ +} + +void GuestSessionEventListener::uninit(void) +{ + GuestEventProcs::iterator itProc = mProcs.begin(); + while (itProc != mProcs.end()) + { + if (!itProc->first.isNull()) + { + HRESULT rc; + do + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR_BREAK(itProc->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR_BREAK(pES, UnregisterListener(itProc->second.mListener)); + } while (0); + itProc->first->Release(); + } + + ++itProc; + } + mProcs.clear(); + + GuestEventFiles::iterator itFile = mFiles.begin(); + while (itFile != mFiles.end()) + { + if (!itFile->first.isNull()) + { + HRESULT rc; + do + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR_BREAK(itFile->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR_BREAK(pES, UnregisterListener(itFile->second.mListener)); + } while (0); + itFile->first->Release(); + } + + ++itFile; + } + mFiles.clear(); +} + +STDMETHODIMP GuestSessionEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent) +{ + switch (aType) + { + case VBoxEventType_OnGuestFileRegistered: + { + HRESULT rc; + do + { + ComPtr<IGuestFileRegisteredEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + + ComPtr<IGuestFile> pFile; + CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pFile.asOutParam())); + AssertBreak(!pFile.isNull()); + BOOL fRegistered; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered)); + Bstr strPath; + CHECK_ERROR_BREAK(pFile, COMGETTER(Filename)(strPath.asOutParam())); + + RTPrintf("File \"%s\" %s\n", + Utf8Str(strPath).c_str(), + fRegistered ? "registered" : "unregistered"); + if (fRegistered) + { + if (mfVerbose) + RTPrintf("Registering ...\n"); + + /* Register for IGuestFile events. */ + ComObjPtr<GuestFileEventListenerImpl> pListener; + pListener.createObject(); + CHECK_ERROR_BREAK(pListener, init(new GuestFileEventListener())); + + ComPtr<IEventSource> es; + CHECK_ERROR_BREAK(pFile, COMGETTER(EventSource)(es.asOutParam())); + com::SafeArray<VBoxEventType_T> eventTypes; + eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged); + CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes), + true /* Active listener */)); + + GuestFileStats fileStats(pListener); + mFiles[pFile] = fileStats; + } + else + { + GuestEventFiles::iterator itFile = mFiles.find(pFile); + if (itFile != mFiles.end()) + { + if (mfVerbose) + RTPrintf("Unregistering file ...\n"); + + if (!itFile->first.isNull()) + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR(itFile->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR(pES, UnregisterListener(itFile->second.mListener)); + itFile->first->Release(); + } + + mFiles.erase(itFile); + } + } + + } while (0); + break; + } + + case VBoxEventType_OnGuestProcessRegistered: + { + HRESULT rc; + do + { + ComPtr<IGuestProcessRegisteredEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + + ComPtr<IGuestProcess> pProcess; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Process)(pProcess.asOutParam())); + AssertBreak(!pProcess.isNull()); + BOOL fRegistered; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered)); + Bstr strPath; + CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam())); + + RTPrintf("Process \"%s\" %s\n", + Utf8Str(strPath).c_str(), + fRegistered ? "registered" : "unregistered"); + if (fRegistered) + { + if (mfVerbose) + RTPrintf("Registering ...\n"); + + /* Register for IGuestProcess events. */ + ComObjPtr<GuestProcessEventListenerImpl> pListener; + pListener.createObject(); + CHECK_ERROR_BREAK(pListener, init(new GuestProcessEventListener())); + + ComPtr<IEventSource> es; + CHECK_ERROR_BREAK(pProcess, COMGETTER(EventSource)(es.asOutParam())); + com::SafeArray<VBoxEventType_T> eventTypes; + eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged); + CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes), + true /* Active listener */)); + + GuestProcStats procStats(pListener); + mProcs[pProcess] = procStats; + } + else + { + GuestEventProcs::iterator itProc = mProcs.find(pProcess); + if (itProc != mProcs.end()) + { + if (mfVerbose) + RTPrintf("Unregistering process ...\n"); + + if (!itProc->first.isNull()) + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR(itProc->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR(pES, UnregisterListener(itProc->second.mListener)); + itProc->first->Release(); + } + + mProcs.erase(itProc); + } + } + + } while (0); + break; + } + + case VBoxEventType_OnGuestSessionStateChanged: + { + HRESULT rc; + do + { + ComPtr<IGuestSessionStateChangedEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + ComPtr<IGuestSession> pSession; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Session)(pSession.asOutParam())); + AssertBreak(!pSession.isNull()); + + GuestSessionStatus_T sessSts; + CHECK_ERROR_BREAK(pSession, COMGETTER(Status)(&sessSts)); + ULONG uID; + CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID)); + Bstr strName; + CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam())); + + RTPrintf("Session ID=%RU32 \"%s\" changed status to [%s]\n", + uID, Utf8Str(strName).c_str(), gctlGuestSessionStatusToText(sessSts)); + + } while (0); + break; + } + + default: + AssertFailed(); + } + + return S_OK; +} + + +/* + * GuestEventListener + * GuestEventListener + * GuestEventListener + */ + +GuestEventListener::GuestEventListener(void) +{ +} + +GuestEventListener::~GuestEventListener(void) +{ +} + +void GuestEventListener::uninit(void) +{ + GuestEventSessions::iterator itSession = mSessions.begin(); + while (itSession != mSessions.end()) + { + if (!itSession->first.isNull()) + { + HRESULT rc; + do + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR_BREAK(itSession->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR_BREAK(pES, UnregisterListener(itSession->second.mListener)); + + } while (0); + itSession->first->Release(); + } + + ++itSession; + } + mSessions.clear(); +} + +STDMETHODIMP GuestEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent) +{ + switch (aType) + { + case VBoxEventType_OnGuestSessionRegistered: + { + HRESULT rc; + do + { + ComPtr<IGuestSessionRegisteredEvent> pEvent = aEvent; + Assert(!pEvent.isNull()); + + ComPtr<IGuestSession> pSession; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Session)(pSession.asOutParam())); + AssertBreak(!pSession.isNull()); + BOOL fRegistered; + CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered)); + Bstr strName; + CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam())); + ULONG uID; + CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID)); + + RTPrintf("Session ID=%RU32 \"%s\" %s\n", + uID, Utf8Str(strName).c_str(), + fRegistered ? "registered" : "unregistered"); + if (fRegistered) + { + if (mfVerbose) + RTPrintf("Registering ...\n"); + + /* Register for IGuestSession events. */ + ComObjPtr<GuestSessionEventListenerImpl> pListener; + pListener.createObject(); + CHECK_ERROR_BREAK(pListener, init(new GuestSessionEventListener())); + + ComPtr<IEventSource> es; + CHECK_ERROR_BREAK(pSession, COMGETTER(EventSource)(es.asOutParam())); + com::SafeArray<VBoxEventType_T> eventTypes; + eventTypes.push_back(VBoxEventType_OnGuestFileRegistered); + eventTypes.push_back(VBoxEventType_OnGuestProcessRegistered); + CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes), + true /* Active listener */)); + + GuestSessionStats sessionStats(pListener); + mSessions[pSession] = sessionStats; + } + else + { + GuestEventSessions::iterator itSession = mSessions.find(pSession); + if (itSession != mSessions.end()) + { + if (mfVerbose) + RTPrintf("Unregistering ...\n"); + + if (!itSession->first.isNull()) + { + /* Listener unregistration. */ + ComPtr<IEventSource> pES; + CHECK_ERROR_BREAK(itSession->first, COMGETTER(EventSource)(pES.asOutParam())); + if (!pES.isNull()) + CHECK_ERROR_BREAK(pES, UnregisterListener(itSession->second.mListener)); + itSession->first->Release(); + } + + mSessions.erase(itSession); + } + } + + } while (0); + break; + } + + default: + AssertFailed(); + } + + return S_OK; +} + +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp new file mode 100644 index 00000000..36ccc472 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageGuestProp.cpp @@ -0,0 +1,437 @@ +/* $Id: VBoxManageGuestProp.cpp $ */ +/** @file + * VBoxManage - Implementation of guestproperty command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxManage.h" + +#ifndef VBOX_ONLY_DOCS + +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <VBox/log.h> +#include <iprt/asm.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/time.h> +#include <iprt/thread.h> + +#ifdef USE_XPCOM_QUEUE +# include <sys/select.h> +# include <errno.h> +#endif + +#ifdef RT_OS_DARWIN +# include <CoreFoundation/CFRunLoop.h> +#endif + +using namespace com; + +#endif /* !VBOX_ONLY_DOCS */ + +void usageGuestProperty(PRTSTREAM pStrm, const char *pcszSep1, const char *pcszSep2) +{ + RTStrmPrintf(pStrm, + "%s guestproperty %s get <uuid|vmname>\n" + " <property> [--verbose]\n" + "\n", pcszSep1, pcszSep2); + RTStrmPrintf(pStrm, + "%s guestproperty %s set <uuid|vmname>\n" + " <property> [<value> [--flags <flags>]]\n" + "\n", pcszSep1, pcszSep2); + RTStrmPrintf(pStrm, + "%s guestproperty %s delete|unset <uuid|vmname>\n" + " <property>\n" + "\n", pcszSep1, pcszSep2); + RTStrmPrintf(pStrm, + "%s guestproperty %s enumerate <uuid|vmname>\n" + " [--patterns <patterns>]\n" + "\n", pcszSep1, pcszSep2); + RTStrmPrintf(pStrm, + "%s guestproperty %s wait <uuid|vmname> <patterns>\n" + " [--timeout <msec>] [--fail-on-timeout]\n" + "\n", pcszSep1, pcszSep2); +} + +#ifndef VBOX_ONLY_DOCS + +static RTEXITCODE handleGetGuestProperty(HandlerArg *a) +{ + HRESULT rc = S_OK; + + bool verbose = false; + if ( a->argc == 3 + && ( !strcmp(a->argv[2], "--verbose") + || !strcmp(a->argv[2], "-verbose"))) + verbose = true; + else if (a->argc != 2) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* open a session for the VM - new or existing */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + + Bstr value; + LONG64 i64Timestamp; + Bstr flags; + CHECK_ERROR(machine, GetGuestProperty(Bstr(a->argv[1]).raw(), + value.asOutParam(), + &i64Timestamp, flags.asOutParam())); + if (value.isEmpty()) + RTPrintf("No value set!\n"); + else + RTPrintf("Value: %ls\n", value.raw()); + if (!value.isEmpty() && verbose) + { + RTPrintf("Timestamp: %lld\n", i64Timestamp); + RTPrintf("Flags: %ls\n", flags.raw()); + } + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static RTEXITCODE handleSetGuestProperty(HandlerArg *a) +{ + HRESULT rc = S_OK; + + /* + * Check the syntax. We can deduce the correct syntax from the number of + * arguments. + */ + bool usageOK = true; + const char *pszName = NULL; + const char *pszValue = NULL; + const char *pszFlags = NULL; + if (a->argc == 3) + pszValue = a->argv[2]; + else if (a->argc == 4) + usageOK = false; + else if (a->argc == 5) + { + pszValue = a->argv[2]; + if ( strcmp(a->argv[3], "--flags") + && strcmp(a->argv[3], "-flags")) + usageOK = false; + pszFlags = a->argv[4]; + } + else if (a->argc != 2) + usageOK = false; + if (!usageOK) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + /* This is always needed. */ + pszName = a->argv[1]; + + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* open a session for the VM - new or existing */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + + if (!pszFlags) + CHECK_ERROR(machine, SetGuestPropertyValue(Bstr(pszName).raw(), + Bstr(pszValue).raw())); + else + CHECK_ERROR(machine, SetGuestProperty(Bstr(pszName).raw(), + Bstr(pszValue).raw(), + Bstr(pszFlags).raw())); + + if (SUCCEEDED(rc)) + CHECK_ERROR(machine, SaveSettings()); + + a->session->UnlockMachine(); + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static RTEXITCODE handleDeleteGuestProperty(HandlerArg *a) +{ + HRESULT rc = S_OK; + + /* + * Check the syntax. We can deduce the correct syntax from the number of + * arguments. + */ + bool usageOK = true; + const char *pszName = NULL; + if (a->argc != 2) + usageOK = false; + if (!usageOK) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + /* This is always needed. */ + pszName = a->argv[1]; + + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* open a session for the VM - new or existing */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + + CHECK_ERROR(machine, DeleteGuestProperty(Bstr(pszName).raw())); + + if (SUCCEEDED(rc)) + CHECK_ERROR(machine, SaveSettings()); + + a->session->UnlockMachine(); + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +/** + * Enumerates the properties in the guest property store. + * + * @returns 0 on success, 1 on failure + * @note see the command line API description for parameters + */ +static RTEXITCODE handleEnumGuestProperty(HandlerArg *a) +{ + /* + * Check the syntax. We can deduce the correct syntax from the number of + * arguments. + */ + if ( a->argc < 1 + || a->argc == 2 + || ( a->argc > 3 + && strcmp(a->argv[1], "--patterns") + && strcmp(a->argv[1], "-patterns"))) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + + /* + * Pack the patterns + */ + Utf8Str Utf8Patterns(a->argc > 2 ? a->argv[2] : ""); + for (int i = 3; i < a->argc; ++i) + Utf8Patterns = Utf8StrFmt ("%s,%s", Utf8Patterns.c_str(), a->argv[i]); + + /* + * Make the actual call to Main. + */ + ComPtr<IMachine> machine; + HRESULT rc; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* open a session for the VM - new or existing */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + + com::SafeArray<BSTR> names; + com::SafeArray<BSTR> values; + com::SafeArray<LONG64> timestamps; + com::SafeArray<BSTR> flags; + CHECK_ERROR(machine, EnumerateGuestProperties(Bstr(Utf8Patterns).raw(), + ComSafeArrayAsOutParam(names), + ComSafeArrayAsOutParam(values), + ComSafeArrayAsOutParam(timestamps), + ComSafeArrayAsOutParam(flags))); + if (SUCCEEDED(rc)) + { + if (names.size() == 0) + RTPrintf("No properties found.\n"); + for (unsigned i = 0; i < names.size(); ++i) + RTPrintf("Name: %ls, value: %ls, timestamp: %lld, flags: %ls\n", + names[i], values[i], timestamps[i], flags[i]); + } + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +/** + * Enumerates the properties in the guest property store. + * + * @returns 0 on success, 1 on failure + * @note see the command line API description for parameters + */ +static RTEXITCODE handleWaitGuestProperty(HandlerArg *a) +{ + /* + * Handle arguments + */ + bool fFailOnTimeout = false; + const char *pszPatterns = NULL; + uint32_t cMsTimeout = RT_INDEFINITE_WAIT; + bool usageOK = true; + if (a->argc < 2) + usageOK = false; + else + pszPatterns = a->argv[1]; + ComPtr<IMachine> machine; + HRESULT rc; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (!machine) + usageOK = false; + for (int i = 2; usageOK && i < a->argc; ++i) + { + if ( !strcmp(a->argv[i], "--timeout") + || !strcmp(a->argv[i], "-timeout")) + { + if ( i + 1 >= a->argc + || RTStrToUInt32Full(a->argv[i + 1], 10, &cMsTimeout) != VINF_SUCCESS) + usageOK = false; + else + ++i; + } + else if (!strcmp(a->argv[i], "--fail-on-timeout")) + fFailOnTimeout = true; + else + usageOK = false; + } + if (!usageOK) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + + /* + * Set up the event listener and wait until found match or timeout. + */ + Bstr aMachStrGuid; + machine->COMGETTER(Id)(aMachStrGuid.asOutParam()); + Guid aMachGuid(aMachStrGuid); + ComPtr<IEventSource> es; + CHECK_ERROR(a->virtualBox, COMGETTER(EventSource)(es.asOutParam())); + ComPtr<IEventListener> listener; + CHECK_ERROR(es, CreateListener(listener.asOutParam())); + com::SafeArray <VBoxEventType_T> eventTypes(1); + eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged); + CHECK_ERROR(es, RegisterListener(listener, ComSafeArrayAsInParam(eventTypes), false)); + + uint64_t u64Started = RTTimeMilliTS(); + bool fSignalled = false; + do + { + unsigned cMsWait; + if (cMsTimeout == RT_INDEFINITE_WAIT) + cMsWait = 1000; + else + { + uint64_t cMsElapsed = RTTimeMilliTS() - u64Started; + if (cMsElapsed >= cMsTimeout) + break; /* timed out */ + cMsWait = RT_MIN(1000, cMsTimeout - (uint32_t)cMsElapsed); + } + + ComPtr<IEvent> ev; + rc = es->GetEvent(listener, cMsWait, ev.asOutParam()); + if (ev) + { + VBoxEventType_T aType; + rc = ev->COMGETTER(Type)(&aType); + switch (aType) + { + case VBoxEventType_OnGuestPropertyChanged: + { + ComPtr<IGuestPropertyChangedEvent> gpcev = ev; + Assert(gpcev); + Bstr aNextStrGuid; + gpcev->COMGETTER(MachineId)(aNextStrGuid.asOutParam()); + if (aMachGuid != Guid(aNextStrGuid)) + continue; + Bstr aNextName; + gpcev->COMGETTER(Name)(aNextName.asOutParam()); + if (RTStrSimplePatternMultiMatch(pszPatterns, RTSTR_MAX, + Utf8Str(aNextName).c_str(), RTSTR_MAX, NULL)) + { + Bstr aNextValue, aNextFlags; + gpcev->COMGETTER(Value)(aNextValue.asOutParam()); + gpcev->COMGETTER(Flags)(aNextFlags.asOutParam()); + RTPrintf("Name: %ls, value: %ls, flags: %ls\n", + aNextName.raw(), aNextValue.raw(), aNextFlags.raw()); + fSignalled = true; + } + break; + } + default: + AssertFailed(); + } + } + } while (!fSignalled); + + es->UnregisterListener(listener); + + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + if (!fSignalled) + { + RTMsgError("Time out or interruption while waiting for a notification."); + if (fFailOnTimeout) + /* Hysterical rasins: We always returned 2 here, which now translates to syntax error... Which is bad. */ + rcExit = RTEXITCODE_SYNTAX; + } + return rcExit; +} + +/** + * Access the guest property store. + * + * @returns 0 on success, 1 on failure + * @note see the command line API description for parameters + */ +RTEXITCODE handleGuestProperty(HandlerArg *a) +{ + HandlerArg arg = *a; + arg.argc = a->argc - 1; + arg.argv = a->argv + 1; + + /** @todo This command does not follow the syntax where the <uuid|vmname> + * comes between the command and subcommand. The commands controlvm, + * snapshot and debugvm puts it between. + */ + + if (a->argc == 0) + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); + + /* switch (cmd) */ + if (strcmp(a->argv[0], "get") == 0) + return handleGetGuestProperty(&arg); + if (strcmp(a->argv[0], "set") == 0) + return handleSetGuestProperty(&arg); + if (strcmp(a->argv[0], "delete") == 0 || strcmp(a->argv[0], "unset") == 0) + return handleDeleteGuestProperty(&arg); + if (strcmp(a->argv[0], "enumerate") == 0) + return handleEnumGuestProperty(&arg); + if (strcmp(a->argv[0], "wait") == 0) + return handleWaitGuestProperty(&arg); + + /* default: */ + return errorSyntax(USAGE_GUESTPROPERTY, "Incorrect parameters"); +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp new file mode 100644 index 00000000..4b8c7390 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp @@ -0,0 +1,1404 @@ +/* $Id: VBoxManageHelp.cpp $ */ +/** @file + * VBoxManage - help and other message output. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/version.h> + +#include <iprt/buildconfig.h> +#include <iprt/ctype.h> +#include <iprt/env.h> +#include <iprt/err.h> +#include <iprt/getopt.h> +#include <iprt/stream.h> +#include <iprt/message.h> + +#include "VBoxManage.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** If the usage is the given number of length long or longer, the error is + * repeated so the user can actually see it. */ +#define ERROR_REPEAT_AFTER_USAGE_LENGTH 16 + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +enum HELP_CMD_VBOXMANAGE g_enmCurCommand = HELP_CMD_VBOXMANAGE_INVALID; +/** The scope maskt for the current subcommand. */ +uint64_t g_fCurSubcommandScope = RTMSGREFENTRYSTR_SCOPE_GLOBAL; + +/** + * Sets the current command. + * + * This affects future calls to error and help functions. + * + * @param enmCommand The command. + */ +void setCurrentCommand(enum HELP_CMD_VBOXMANAGE enmCommand) +{ + Assert(g_enmCurCommand == HELP_CMD_VBOXMANAGE_INVALID); + g_enmCurCommand = enmCommand; + g_fCurSubcommandScope = RTMSGREFENTRYSTR_SCOPE_GLOBAL; +} + + +/** + * Sets the current subcommand. + * + * This affects future calls to error and help functions. + * + * @param fSubcommandScope The subcommand scope. + */ +void setCurrentSubcommand(uint64_t fSubcommandScope) +{ + g_fCurSubcommandScope = fSubcommandScope; +} + + + + +/** + * Prints brief help for a command or subcommand. + * + * @returns Number of lines written. + * @param enmCommand The command. + * @param fSubcommandScope The subcommand scope, REFENTRYSTR_SCOPE_GLOBAL + * for all. + * @param pStrm The output stream. + */ +static uint32_t printBriefCommandOrSubcommandHelp(enum HELP_CMD_VBOXMANAGE enmCommand, uint64_t fSubcommandScope, PRTSTREAM pStrm) +{ + uint32_t cLinesWritten = 0; + uint32_t cPendingBlankLines = 0; + uint32_t cFound = 0; + for (uint32_t i = 0; i < g_cHelpEntries; i++) + { + PCRTMSGREFENTRY pHelp = g_apHelpEntries[i]; + if (pHelp->idInternal == (int64_t)enmCommand) + { + cFound++; + if (cFound == 1) + { + if (fSubcommandScope == RTMSGREFENTRYSTR_SCOPE_GLOBAL) + RTStrmPrintf(pStrm, "Usage - %c%s:\n", RT_C_TO_UPPER(pHelp->pszBrief[0]), pHelp->pszBrief + 1); + else + RTStrmPrintf(pStrm, "Usage:\n"); + } + RTMsgRefEntryPrintStringTable(pStrm, &pHelp->Synopsis, fSubcommandScope, &cPendingBlankLines, &cLinesWritten); + if (!cPendingBlankLines) + cPendingBlankLines = 1; + } + } + Assert(cFound > 0); + return cLinesWritten; +} + + +/** + * Prints the brief usage information for the current (sub)command. + * + * @param pStrm The output stream. + */ +void printUsage(PRTSTREAM pStrm) +{ + printBriefCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, pStrm); +} + + +/** + * Prints full help for a command or subcommand. + * + * @param enmCommand The command. + * @param fSubcommandScope The subcommand scope, REFENTRYSTR_SCOPE_GLOBAL + * for all. + * @param pStrm The output stream. + */ +static void printFullCommandOrSubcommandHelp(enum HELP_CMD_VBOXMANAGE enmCommand, uint64_t fSubcommandScope, PRTSTREAM pStrm) +{ + uint32_t cPendingBlankLines = 0; + uint32_t cFound = 0; + for (uint32_t i = 0; i < g_cHelpEntries; i++) + { + PCRTMSGREFENTRY pHelp = g_apHelpEntries[i]; + if ( pHelp->idInternal == (int64_t)enmCommand + || enmCommand == HELP_CMD_VBOXMANAGE_INVALID) + { + cFound++; + RTMsgRefEntryPrintStringTable(pStrm, &pHelp->Help, fSubcommandScope, &cPendingBlankLines, NULL /*pcLinesWritten*/); + if (cPendingBlankLines < 2) + cPendingBlankLines = 2; + } + } + Assert(cFound > 0); +} + + +/** + * Prints the full help for the current (sub)command. + * + * @param pStrm The output stream. + */ +void printHelp(PRTSTREAM pStrm) +{ + printFullCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, pStrm); +} + + +/** + * Display no subcommand error message and current command usage. + * + * @returns RTEXITCODE_SYNTAX. + */ +RTEXITCODE errorNoSubcommand(void) +{ + Assert(g_enmCurCommand != HELP_CMD_VBOXMANAGE_INVALID); + Assert(g_fCurSubcommandScope == RTMSGREFENTRYSTR_SCOPE_GLOBAL); + + return errorSyntax("No subcommand specified"); +} + + +/** + * Display unknown subcommand error message and current command usage. + * + * May show full command help instead if the subcommand is a common help option. + * + * @returns RTEXITCODE_SYNTAX, or RTEXITCODE_SUCCESS if common help option. + * @param pszSubcommand The name of the alleged subcommand. + */ +RTEXITCODE errorUnknownSubcommand(const char *pszSubcommand) +{ + Assert(g_enmCurCommand != HELP_CMD_VBOXMANAGE_INVALID); + Assert(g_fCurSubcommandScope == RTMSGREFENTRYSTR_SCOPE_GLOBAL); + + /* check if help was requested. */ + if ( strcmp(pszSubcommand, "--help") == 0 + || strcmp(pszSubcommand, "-h") == 0 + || strcmp(pszSubcommand, "-?") == 0) + { + printFullCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, g_pStdOut); + return RTEXITCODE_SUCCESS; + } + + return errorSyntax("Unknown subcommand: %s", pszSubcommand); +} + + +/** + * Display too many parameters error message and current command usage. + * + * May show full command help instead if the subcommand is a common help option. + * + * @returns RTEXITCODE_SYNTAX, or RTEXITCODE_SUCCESS if common help option. + * @param papszArgs The first unwanted parameter. Terminated by + * NULL entry. + */ +RTEXITCODE errorTooManyParameters(char **papszArgs) +{ + Assert(g_enmCurCommand != HELP_CMD_VBOXMANAGE_INVALID); + Assert(g_fCurSubcommandScope != RTMSGREFENTRYSTR_SCOPE_GLOBAL); + + /* check if help was requested. */ + if (papszArgs) + { + for (uint32_t i = 0; papszArgs[i]; i++) + if ( strcmp(papszArgs[i], "--help") == 0 + || strcmp(papszArgs[i], "-h") == 0 + || strcmp(papszArgs[i], "-?") == 0) + { + printFullCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, g_pStdOut); + return RTEXITCODE_SUCCESS; + } + else if (!strcmp(papszArgs[i], "--")) + break; + } + + return errorSyntax("Too many parameters"); +} + + +/** + * Display current (sub)command usage and the custom error message. + * + * @returns RTEXITCODE_SYNTAX. + * @param pszFormat Custom error message format string. + * @param ... Format arguments. + */ +RTEXITCODE errorSyntax(const char *pszFormat, ...) +{ + Assert(g_enmCurCommand != HELP_CMD_VBOXMANAGE_INVALID); + + showLogo(g_pStdErr); + + va_list va; + va_start(va, pszFormat); + RTMsgErrorV(pszFormat, va); + va_end(va); + + RTStrmPutCh(g_pStdErr, '\n'); + if ( printBriefCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, g_pStdErr) + >= ERROR_REPEAT_AFTER_USAGE_LENGTH) + { + /* Usage was very long, repeat the error message. */ + RTStrmPutCh(g_pStdErr, '\n'); + va_start(va, pszFormat); + RTMsgErrorV(pszFormat, va); + va_end(va); + } + return RTEXITCODE_SYNTAX; +} + + +/** + * Worker for errorGetOpt. + * + * @param rcGetOpt The RTGetOpt return value. + * @param pValueUnion The value union returned by RTGetOpt. + */ +static void errorGetOptWorker(int rcGetOpt, union RTGETOPTUNION const *pValueUnion) +{ + if (rcGetOpt == VINF_GETOPT_NOT_OPTION) + RTMsgError("Invalid parameter '%s'", pValueUnion->psz); + else if (rcGetOpt > 0) + { + if (RT_C_IS_PRINT(rcGetOpt)) + RTMsgError("Invalid option -%c", rcGetOpt); + else + RTMsgError("Invalid option case %i", rcGetOpt); + } + else if (rcGetOpt == VERR_GETOPT_UNKNOWN_OPTION) + RTMsgError("Unknown option: %s", pValueUnion->psz); + else if (rcGetOpt == VERR_GETOPT_INVALID_ARGUMENT_FORMAT) + RTMsgError("Invalid argument format: %s", pValueUnion->psz); + else if (pValueUnion->pDef) + RTMsgError("%s: %Rrs", pValueUnion->pDef->pszLong, rcGetOpt); + else + RTMsgError("%Rrs", rcGetOpt); +} + + +/** + * Handled an RTGetOpt error or common option. + * + * This implements the 'V' and 'h' cases. It reports appropriate syntax errors + * for other @a rcGetOpt values. + * + * @retval RTEXITCODE_SUCCESS if help or version request. + * @retval RTEXITCODE_SYNTAX if not help or version request. + * @param rcGetOpt The RTGetOpt return value. + * @param pValueUnion The value union returned by RTGetOpt. + */ +RTEXITCODE errorGetOpt(int rcGetOpt, union RTGETOPTUNION const *pValueUnion) +{ + Assert(g_enmCurCommand != HELP_CMD_VBOXMANAGE_INVALID); + + /* + * Check if it is an unhandled standard option. + */ + if (rcGetOpt == 'V') + { + RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision()); + return RTEXITCODE_SUCCESS; + } + + if (rcGetOpt == 'h') + { + printFullCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, g_pStdOut); + return RTEXITCODE_SUCCESS; + } + + /* + * We failed. + */ + showLogo(g_pStdErr); + errorGetOptWorker(rcGetOpt, pValueUnion); + if ( printBriefCommandOrSubcommandHelp(g_enmCurCommand, g_fCurSubcommandScope, g_pStdErr) + >= ERROR_REPEAT_AFTER_USAGE_LENGTH) + { + /* Usage was very long, repeat the error message. */ + RTStrmPutCh(g_pStdErr, '\n'); + errorGetOptWorker(rcGetOpt, pValueUnion); + } + return RTEXITCODE_SYNTAX; +} + +#endif /* !VBOX_ONLY_DOCS */ + + + +void showLogo(PRTSTREAM pStrm) +{ + static bool s_fShown; /* show only once */ + + if (!s_fShown) + { + RTStrmPrintf(pStrm, VBOX_PRODUCT " Command Line Management Interface Version " + VBOX_VERSION_STRING "\n" + "(C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\n" + "All rights reserved.\n" + "\n"); + s_fShown = true; + } +} + + + + +void printUsage(USAGECATEGORY fCategory, uint32_t fSubCategory, PRTSTREAM pStrm) +{ + bool fDumpOpts = false; +#ifdef RT_OS_LINUX + bool fLinux = true; +#else + bool fLinux = false; +#endif +#ifdef RT_OS_WINDOWS + bool fWin = true; +#else + bool fWin = false; +#endif +#ifdef RT_OS_SOLARIS + bool fSolaris = true; +#else + bool fSolaris = false; +#endif +#ifdef RT_OS_FREEBSD + bool fFreeBSD = true; +#else + bool fFreeBSD = false; +#endif +#ifdef RT_OS_DARWIN + bool fDarwin = true; +#else + bool fDarwin = false; +#endif +#ifdef VBOX_WITH_VBOXSDL + bool fVBoxSDL = true; +#else + bool fVBoxSDL = false; +#endif + + if (fCategory == USAGE_DUMPOPTS) + { + fDumpOpts = true; + fLinux = true; + fWin = true; + fSolaris = true; + fFreeBSD = true; + fDarwin = true; + fVBoxSDL = true; + fCategory = USAGE_ALL; + } + + RTStrmPrintf(pStrm, + "Usage:\n" + "\n"); + + if (fCategory == USAGE_ALL) + RTStrmPrintf(pStrm, + " VBoxManage [<general option>] <command>\n" + " \n \n" + "General Options:\n \n" + " [-v|--version] print version number and exit\n" + " [-q|--nologo] suppress the logo\n" + " [--settingspw <pw>] provide the settings password\n" + " [--settingspwfile <file>] provide a file containing the settings password\n" + " [@<response-file>] load arguments from the given response file (bourne style)\n" + " \n \n" + "Commands:\n \n"); + + const char *pcszSep1 = " "; + const char *pcszSep2 = " "; + if (fCategory != USAGE_ALL) + { + pcszSep1 = "VBoxManage"; + pcszSep2 = ""; + } + +#define SEP pcszSep1, pcszSep2 + + if (fCategory & USAGE_LIST) + RTStrmPrintf(pStrm, + "%s list [--long|-l] [--sorted|-s]%s vms|runningvms|ostypes|hostdvds|hostfloppies|\n" +#if defined(VBOX_WITH_NETFLT) + " intnets|bridgedifs|hostonlyifs|natnets|dhcpservers|\n" +#else + " intnets|bridgedifs|natnets|dhcpservers|hostinfo|\n" +#endif + " hostinfo|hostcpuids|hddbackends|hdds|dvds|floppies|\n" + " usbhost|usbfilters|systemproperties|extpacks|\n" + " groups|webcams|screenshotformats|cloudproviders|\n" + " cloudprofiles\n" + "\n", SEP); + + if (fCategory & USAGE_SHOWVMINFO) + RTStrmPrintf(pStrm, + "%s showvminfo %s <uuid|vmname> [--details]\n" + " [--machinereadable]\n" + "%s showvminfo %s <uuid|vmname> --log <idx>\n" + "\n", SEP, SEP); + + if (fCategory & USAGE_REGISTERVM) + RTStrmPrintf(pStrm, + "%s registervm %s <filename>\n" + "\n", SEP); + + if (fCategory & USAGE_UNREGISTERVM) + RTStrmPrintf(pStrm, + "%s unregistervm %s <uuid|vmname> [--delete]\n" + "\n", SEP); + + if (fCategory & USAGE_CREATEVM) + RTStrmPrintf(pStrm, + "%s createvm %s --name <name>\n" + " [--groups <group>, ...]\n" + " [--ostype <ostype>]\n" + " [--register]\n" + " [--basefolder <path>]\n" + " [--uuid <uuid>]\n" + " [--default]\n" + "\n", SEP); + + if (fCategory & USAGE_MODIFYVM) + { + RTStrmPrintf(pStrm, + "%s modifyvm %s <uuid|vmname>\n" + " [--name <name>]\n" + " [--groups <group>, ...]\n" + " [--description <desc>]\n" + " [--ostype <ostype>]\n" + " [--iconfile <filename>]\n" + " [--memory <memorysize in MB>]\n" + " [--pagefusion on|off]\n" + " [--vram <vramsize in MB>]\n" + " [--acpi on|off]\n" +#ifdef VBOX_WITH_PCI_PASSTHROUGH + " [--pciattach 03:04.0]\n" + " [--pciattach 03:04.0@02:01.0]\n" + " [--pcidetach 03:04.0]\n" +#endif + " [--ioapic on|off]\n" + " [--hpet on|off]\n" + " [--triplefaultreset on|off]\n" + " [--apic on|off]\n" + " [--x2apic on|off]\n" + " [--paravirtprovider none|default|legacy|minimal|\n" + " hyperv|kvm]\n" + " [--paravirtdebug <key=value> [,<key=value> ...]]\n" + " [--hwvirtex on|off]\n" + " [--nestedpaging on|off]\n" + " [--largepages on|off]\n" + " [--vtxvpid on|off]\n" + " [--vtxux on|off]\n" + " [--pae on|off]\n" + " [--longmode on|off]\n" + " [--ibpb-on-vm-exit on|off]\n" + " [--ibpb-on-vm-entry on|off]\n" + " [--spec-ctrl on|off]\n" + " [--l1d-flush-on-sched on|off]\n" + " [--l1d-flush-on-vm-entry on|off]\n" + " [--nested-hw-virt on|off]\n" + " [--cpu-profile \"host|Intel 80[86|286|386]\"]\n" + " [--cpuid-portability-level <0..3>\n" + " [--cpuid-set <leaf[:subleaf]> <eax> <ebx> <ecx> <edx>]\n" + " [--cpuid-remove <leaf[:subleaf]>]\n" + " [--cpuidremoveall]\n" + " [--hardwareuuid <uuid>]\n" + " [--cpus <number>]\n" + " [--cpuhotplug on|off]\n" + " [--plugcpu <id>]\n" + " [--unplugcpu <id>]\n" + " [--cpuexecutioncap <1-100>]\n" + " [--rtcuseutc on|off]\n" +#ifdef VBOX_WITH_VMSVGA + " [--graphicscontroller none|vboxvga|vmsvga|vboxsvga]\n" +#else + " [--graphicscontroller none|vboxvga]\n" +#endif + " [--monitorcount <number>]\n" + " [--accelerate3d on|off]\n" +#ifdef VBOX_WITH_VIDEOHWACCEL + " [--accelerate2dvideo on|off]\n" +#endif + " [--firmware bios|efi|efi32|efi64]\n" + " [--chipset ich9|piix3]\n" + " [--bioslogofadein on|off]\n" + " [--bioslogofadeout on|off]\n" + " [--bioslogodisplaytime <msec>]\n" + " [--bioslogoimagepath <imagepath>]\n" + " [--biosbootmenu disabled|menuonly|messageandmenu]\n" + " [--biosapic disabled|apic|x2apic]\n" + " [--biossystemtimeoffset <msec>]\n" + " [--biospxedebug on|off]\n" + " [--boot<1-4> none|floppy|dvd|disk|net>]\n" + " [--nic<1-N> none|null|nat|bridged|intnet" +#if defined(VBOX_WITH_NETFLT) + "|hostonly" +#endif + "|\n" + " generic|natnetwork" + "]\n" + " [--nictype<1-N> Am79C970A|Am79C973" +#ifdef VBOX_WITH_E1000 + "|\n 82540EM|82543GC|82545EM" +#endif +#ifdef VBOX_WITH_VIRTIO + "|\n virtio" +#endif /* VBOX_WITH_VIRTIO */ + "]\n" + " [--cableconnected<1-N> on|off]\n" + " [--nictrace<1-N> on|off]\n" + " [--nictracefile<1-N> <filename>]\n" + " [--nicproperty<1-N> name=[value]]\n" + " [--nicspeed<1-N> <kbps>]\n" + " [--nicbootprio<1-N> <priority>]\n" + " [--nicpromisc<1-N> deny|allow-vms|allow-all]\n" + " [--nicbandwidthgroup<1-N> none|<name>]\n" + " [--bridgeadapter<1-N> none|<devicename>]\n" +#if defined(VBOX_WITH_NETFLT) + " [--hostonlyadapter<1-N> none|<devicename>]\n" +#endif + " [--intnet<1-N> <network name>]\n" + " [--nat-network<1-N> <network name>]\n" + " [--nicgenericdrv<1-N> <driver>\n" + " [--natnet<1-N> <network>|default]\n" + " [--natsettings<1-N> [<mtu>],[<socksnd>],\n" + " [<sockrcv>],[<tcpsnd>],\n" + " [<tcprcv>]]\n" + " [--natpf<1-N> [<rulename>],tcp|udp,[<hostip>],\n" + " <hostport>,[<guestip>],<guestport>]\n" + " [--natpf<1-N> delete <rulename>]\n" + " [--nattftpprefix<1-N> <prefix>]\n" + " [--nattftpfile<1-N> <file>]\n" + " [--nattftpserver<1-N> <ip>]\n" + " [--natbindip<1-N> <ip>\n" + " [--natdnspassdomain<1-N> on|off]\n" + " [--natdnsproxy<1-N> on|off]\n" + " [--natdnshostresolver<1-N> on|off]\n" + " [--nataliasmode<1-N> default|[log],[proxyonly],\n" + " [sameports]]\n" + " [--macaddress<1-N> auto|<mac>]\n" + " [--mouse ps2|usb|usbtablet|usbmultitouch]\n" + " [--keyboard ps2|usb\n" + " [--uart<1-N> off|<I/O base> <IRQ>]\n" + " [--uartmode<1-N> disconnected|\n" + " server <pipe>|\n" + " client <pipe>|\n" + " tcpserver <port>|\n" + " tcpclient <hostname:port>|\n" + " file <file>|\n" + " <devicename>]\n" + " [--uarttype<1-N> 16450|16550A|16750\n" +#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS) + " [--lpt<1-N> off|<I/O base> <IRQ>]\n" + " [--lptmode<1-N> <devicename>]\n" +#endif + " [--guestmemoryballoon <balloonsize in MB>]\n" + " [--audio none|null", SEP); + if (fWin) + { +#ifdef VBOX_WITH_WINMM + RTStrmPrintf(pStrm, "|winmm|dsound"); +#else + RTStrmPrintf(pStrm, "|dsound"); +#endif + } + if (fLinux || fSolaris) + { + RTStrmPrintf(pStrm, "" +#ifdef VBOX_WITH_AUDIO_OSS + "|oss" +#endif +#ifdef VBOX_WITH_AUDIO_ALSA + "|alsa" +#endif +#ifdef VBOX_WITH_AUDIO_PULSE + "|pulse" +#endif + ); + } + if (fFreeBSD) + { +#ifdef VBOX_WITH_AUDIO_OSS + /* Get the line break sorted when dumping all option variants. */ + if (fDumpOpts) + { + RTStrmPrintf(pStrm, "|\n" + " oss"); + } + else + RTStrmPrintf(pStrm, "|oss"); +#endif +#ifdef VBOX_WITH_AUDIO_PULSE + RTStrmPrintf(pStrm, "|pulse"); +#endif + } + if (fDarwin) + { + RTStrmPrintf(pStrm, "|coreaudio"); + } + RTStrmPrintf(pStrm, "]\n"); + RTStrmPrintf(pStrm, + " [--audioin on|off]\n" + " [--audioout on|off]\n" + " [--audiocontroller ac97|hda|sb16]\n" + " [--audiocodec stac9700|ad1980|stac9221|sb16]\n" + " [--clipboard disabled|hosttoguest|guesttohost|\n" + " bidirectional]\n" + " [--draganddrop disabled|hosttoguest|guesttohost|\n" + " bidirectional]\n"); + RTStrmPrintf(pStrm, + " [--vrde on|off]\n" + " [--vrdeextpack default|<name>\n" + " [--vrdeproperty <name=[value]>]\n" + " [--vrdeport <hostport>]\n" + " [--vrdeaddress <hostip>]\n" + " [--vrdeauthtype null|external|guest]\n" + " [--vrdeauthlibrary default|<name>\n" + " [--vrdemulticon on|off]\n" + " [--vrdereusecon on|off]\n" + " [--vrdevideochannel on|off]\n" + " [--vrdevideochannelquality <percent>]\n"); + RTStrmPrintf(pStrm, + " [--usbohci on|off]\n" + " [--usbehci on|off]\n" + " [--usbxhci on|off]\n" + " [--usbrename <oldname> <newname>]\n" + " [--snapshotfolder default|<path>]\n" + " [--teleporter on|off]\n" + " [--teleporterport <port>]\n" + " [--teleporteraddress <address|empty>\n" + " [--teleporterpassword <password>]\n" + " [--teleporterpasswordfile <file>|stdin]\n" + " [--tracing-enabled on|off]\n" + " [--tracing-config <config-string>]\n" + " [--tracing-allow-vm-access on|off]\n" +#if 0 + " [--iocache on|off]\n" + " [--iocachesize <I/O cache size in MB>]\n" +#endif +#if 0 + " [--faulttolerance master|standby]\n" + " [--faulttoleranceaddress <name>]\n" + " [--faulttoleranceport <port>]\n" + " [--faulttolerancesyncinterval <msec>]\n" + " [--faulttolerancepassword <password>]\n" +#endif +#ifdef VBOX_WITH_USB_CARDREADER + " [--usbcardreader on|off]\n" +#endif + " [--autostart-enabled on|off]\n" + " [--autostart-delay <seconds>]\n" +#if 0 + " [--autostop-type disabled|savestate|poweroff|\n" + " acpishutdown]\n" +#endif +#ifdef VBOX_WITH_RECORDING + " [--recording on|off]\n" + " [--recording screens all|<screen ID> [<screen ID> ...]]\n" + " [--recording filename <filename>]\n" + " [--recording videores <width> <height>]\n" + " [--recording videorate <rate>]\n" + " [--recording videofps <fps>]\n" + " [--recording maxtime <s>]\n" + " [--recording maxfilesize <MB>]\n" + " [--recording opts <key=value> [,<key=value> ...]]\n" +#endif + " [--defaultfrontend default|<name>]\n" + "\n"); + } + + if (fCategory & USAGE_CLONEVM) + RTStrmPrintf(pStrm, + "%s clonevm %s <uuid|vmname>\n" + " [--snapshot <uuid>|<name>]\n" + " [--mode machine|machineandchildren|all]\n" + " [--options link|keepallmacs|keepnatmacs|\n" + " keepdisknames|keephwuuids]\n" + " [--name <name>]\n" + " [--groups <group>, ...]\n" + " [--basefolder <basefolder>]\n" + " [--uuid <uuid>]\n" + " [--register]\n" + "\n", SEP); + + if (fCategory & USAGE_MOVEVM) + RTStrmPrintf(pStrm, + "%s movevm %s <uuid|vmname>\n" + " --type basic\n" + " [--folder <path>]\n" + "\n", SEP); + + if (fCategory & USAGE_IMPORTAPPLIANCE) + RTStrmPrintf(pStrm, + "%s import %s <ovfname/ovaname>\n" + " [--dry-run|-n]\n" + " [--options keepallmacs|keepnatmacs|importtovdi]\n" + " [more options]\n" + " (run with -n to have options displayed\n" + " for a particular OVF)\n\n", SEP); + + if (fCategory & USAGE_EXPORTAPPLIANCE) + RTStrmPrintf(pStrm, + "%s export %s <machines> --output|-o <name>.<ovf/ova/tar.gz>\n" + " [--legacy09|--ovf09|--ovf10|--ovf20|--opc10]\n" + " [--manifest]\n" + " [--iso]\n" + " [--options manifest|iso|nomacs|nomacsbutnat]\n" + " [--vsys <number of virtual system>]\n" + " [--vmname <name>]\n" + " [--product <product name>]\n" + " [--producturl <product url>]\n" + " [--vendor <vendor name>]\n" + " [--vendorurl <vendor url>]\n" + " [--version <version info>]\n" + " [--description <description info>]\n" + " [--eula <license text>]\n" + " [--eulafile <filename>]\n" + " [--cloud <number of virtual system>]\n" + " [--vmname <name>]\n" + " [--cloudprofile <cloud profile name>]\n" + " [--cloudshape <shape>]\n" + " [--clouddomain <domain>]\n" + " [--clouddisksize <disk size in GB>]\n" + " [--cloudbucket <bucket name>]\n" + " [--cloudocivcn <OCI vcn id>]\n" + " [--cloudocisubnet <OCI subnet id>]\n" + " [--cloudkeepobject <true/false>]\n" + " [--cloudlaunchinstance <true/false>]\n" + " [--cloudpublicip <true/false>]\n" + "\n", SEP); + + if (fCategory & USAGE_STARTVM) + { + RTStrmPrintf(pStrm, + "%s startvm %s <uuid|vmname>...\n" + " [--type gui", SEP); + if (fVBoxSDL) + RTStrmPrintf(pStrm, "|sdl"); + RTStrmPrintf(pStrm, "|headless|separate]\n"); + RTStrmPrintf(pStrm, + " [-E|--putenv <NAME>[=<VALUE>]]\n" + "\n"); + } + + if (fCategory & USAGE_CONTROLVM) + { + RTStrmPrintf(pStrm, + "%s controlvm %s <uuid|vmname>\n" + " pause|resume|reset|poweroff|savestate|\n" + " acpipowerbutton|acpisleepbutton|\n" + " keyboardputscancode <hex> [<hex> ...]|\n" + " keyboardputstring <string1> [<string2> ...]|\n" + " keyboardputfile <filename>|\n" + " setlinkstate<1-N> on|off |\n" +#if defined(VBOX_WITH_NETFLT) + " nic<1-N> null|nat|bridged|intnet|hostonly|generic|\n" + " natnetwork [<devicename>] |\n" +#else /* !VBOX_WITH_NETFLT */ + " nic<1-N> null|nat|bridged|intnet|generic|natnetwork\n" + " [<devicename>] |\n" +#endif /* !VBOX_WITH_NETFLT */ + " nictrace<1-N> on|off |\n" + " nictracefile<1-N> <filename> |\n" + " nicproperty<1-N> name=[value] |\n" + " nicpromisc<1-N> deny|allow-vms|allow-all |\n" + " natpf<1-N> [<rulename>],tcp|udp,[<hostip>],\n" + " <hostport>,[<guestip>],<guestport> |\n" + " natpf<1-N> delete <rulename> |\n" + " guestmemoryballoon <balloonsize in MB> |\n" + " usbattach <uuid>|<address>\n" + " [--capturefile <filename>] |\n" + " usbdetach <uuid>|<address> |\n" + " audioin on|off |\n" + " audioout on|off |\n" + " clipboard disabled|hosttoguest|guesttohost|\n" + " bidirectional |\n" + " draganddrop disabled|hosttoguest|guesttohost|\n" + " bidirectional |\n" + " vrde on|off |\n" + " vrdeport <port> |\n" + " vrdeproperty <name=[value]> |\n" + " vrdevideochannelquality <percent> |\n" + " setvideomodehint <xres> <yres> <bpp>\n" + " [[<display>] [<enabled:yes|no> |\n" + " [<xorigin> <yorigin>]]] |\n" + " setscreenlayout <display> on|primary <xorigin> <yorigin> <xres> <yres> <bpp> | off\n" + " screenshotpng <file> [display] |\n" +#ifdef VBOX_WITH_RECORDING + " recording on|off |\n" + " recording screens all|none|<screen>,[<screen>...] |\n" + " recording filename <file> |\n" + " recording videores <width>x<height> |\n" + " recording videorate <rate> |\n" + " recording videofps <fps> |\n" + " recording maxtime <s> |\n" + " recording maxfilesize <MB> |\n" +#endif /* VBOX_WITH_RECORDING */ + " setcredentials <username>\n" + " --passwordfile <file> | <password>\n" + " <domain>\n" + " [--allowlocallogon <yes|no>] |\n" + " teleport --host <name> --port <port>\n" + " [--maxdowntime <msec>]\n" + " [--passwordfile <file> |\n" + " --password <password>] |\n" + " plugcpu <id> |\n" + " unplugcpu <id> |\n" + " cpuexecutioncap <1-100>\n" + " webcam <attach [path [settings]]> | <detach [path]> | <list>\n" + " addencpassword <id>\n" + " <password file>|-\n" + " [--removeonsuspend <yes|no>]\n" + " removeencpassword <id>\n" + " removeallencpasswords\n" + " changeuartmode<1-N> disconnected|\n" + " server <pipe>|\n" + " client <pipe>|\n" + " tcpserver <port>|\n" + " tcpclient <hostname:port>|\n" + " file <file>|\n" + " <devicename>]\n" + "\n", SEP); + } + + if (fCategory & USAGE_DISCARDSTATE) + RTStrmPrintf(pStrm, + "%s discardstate %s <uuid|vmname>\n" + "\n", SEP); + + if (fCategory & USAGE_ADOPTSTATE) + RTStrmPrintf(pStrm, + "%s adoptstate %s <uuid|vmname> <state_file>\n" + "\n", SEP); + + if (fCategory & USAGE_SNAPSHOT) + RTStrmPrintf(pStrm, + "%s snapshot %s <uuid|vmname>\n" + " take <name> [--description <desc>] [--live]\n" + " [--uniquename Number,Timestamp,Space,Force] |\n" + " delete <uuid|snapname> |\n" + " restore <uuid|snapname> |\n" + " restorecurrent |\n" + " edit <uuid|snapname>|--current\n" + " [--name <name>]\n" + " [--description <desc>] |\n" + " list [--details|--machinereadable] |\n" + " showvminfo <uuid|snapname>\n" + "\n", SEP); + + if (fCategory & USAGE_CLOSEMEDIUM) + RTStrmPrintf(pStrm, + "%s closemedium %s [disk|dvd|floppy] <uuid|filename>\n" + " [--delete]\n" + "\n", SEP); + + if (fCategory & USAGE_STORAGEATTACH) + RTStrmPrintf(pStrm, + "%s storageattach %s <uuid|vmname>\n" + " --storagectl <name>\n" + " [--port <number>]\n" + " [--device <number>]\n" + " [--type dvddrive|hdd|fdd]\n" + " [--medium none|emptydrive|additions|\n" + " <uuid|filename>|host:<drive>|iscsi]\n" + " [--mtype normal|writethrough|immutable|shareable|\n" + " readonly|multiattach]\n" + " [--comment <text>]\n" + " [--setuuid <uuid>]\n" + " [--setparentuuid <uuid>]\n" + " [--passthrough on|off]\n" + " [--tempeject on|off]\n" + " [--nonrotational on|off]\n" + " [--discard on|off]\n" + " [--hotpluggable on|off]\n" + " [--bandwidthgroup <name>]\n" + " [--forceunmount]\n" + " [--server <name>|<ip>]\n" + " [--target <target>]\n" + " [--tport <port>]\n" + " [--lun <lun>]\n" + " [--encodedlun <lun>]\n" + " [--username <username>]\n" + " [--password <password>]\n" + " [--passwordfile <file>]\n" + " [--initiator <initiator>]\n" + " [--intnet]\n" + "\n", SEP); + + if (fCategory & USAGE_STORAGECONTROLLER) + RTStrmPrintf(pStrm, + "%s storagectl %s <uuid|vmname>\n" + " --name <name>\n" + " [--add ide|sata|scsi|floppy|sas|usb|pcie]\n" + " [--controller LSILogic|LSILogicSAS|BusLogic|\n" + " IntelAHCI|PIIX3|PIIX4|ICH6|I82078|\n" + " [ USB|NVMe]\n" + " [--portcount <1-n>]\n" + " [--hostiocache on|off]\n" + " [--bootable on|off]\n" + " [--rename <name>]\n" + " [--remove]\n" + "\n", SEP); + + if (fCategory & USAGE_BANDWIDTHCONTROL) + RTStrmPrintf(pStrm, + "%s bandwidthctl %s <uuid|vmname>\n" + " add <name> --type disk|network\n" + " --limit <megabytes per second>[k|m|g|K|M|G] |\n" + " set <name>\n" + " --limit <megabytes per second>[k|m|g|K|M|G] |\n" + " remove <name> |\n" + " list [--machinereadable]\n" + " (limit units: k=kilobit, m=megabit, g=gigabit,\n" + " K=kilobyte, M=megabyte, G=gigabyte)\n" + "\n", SEP); + + if (fCategory & USAGE_SHOWMEDIUMINFO) + RTStrmPrintf(pStrm, + "%s showmediuminfo %s [disk|dvd|floppy] <uuid|filename>\n" + "\n", SEP); + + if (fCategory & USAGE_CREATEMEDIUM) + RTStrmPrintf(pStrm, + "%s createmedium %s [disk|dvd|floppy] --filename <filename>\n" + " [--size <megabytes>|--sizebyte <bytes>]\n" + " [--diffparent <uuid>|<filename>\n" + " [--format VDI|VMDK|VHD] (default: VDI)\n" + " [--variant Standard,Fixed,Split2G,Stream,ESX,\n" + " Formatted]\n" + "\n", SEP); + + if (fCategory & USAGE_MODIFYMEDIUM) + RTStrmPrintf(pStrm, + "%s modifymedium %s [disk|dvd|floppy] <uuid|filename>\n" + " [--type normal|writethrough|immutable|shareable|\n" + " readonly|multiattach]\n" + " [--autoreset on|off]\n" + " [--property <name=[value]>]\n" + " [--compact]\n" + " [--resize <megabytes>|--resizebyte <bytes>]\n" + " [--move <path>]\n" + " [--setlocation <path>]\n" + " [--description <description string>]" + "\n", SEP); + + if (fCategory & USAGE_CLONEMEDIUM) + RTStrmPrintf(pStrm, + "%s clonemedium %s [disk|dvd|floppy] <uuid|inputfile> <uuid|outputfile>\n" + " [--format VDI|VMDK|VHD|RAW|<other>]\n" + " [--variant Standard,Fixed,Split2G,Stream,ESX]\n" + " [--existing]\n" + "\n", SEP); + + if (fCategory & USAGE_MEDIUMPROPERTY) + RTStrmPrintf(pStrm, + "%s mediumproperty %s [disk|dvd|floppy] set <uuid|filename>\n" + " <property> <value>\n" + "\n" + " [disk|dvd|floppy] get <uuid|filename>\n" + " <property>\n" + "\n" + " [disk|dvd|floppy] delete <uuid|filename>\n" + " <property>\n" + "\n", SEP); + + if (fCategory & USAGE_ENCRYPTMEDIUM) + RTStrmPrintf(pStrm, + "%s encryptmedium %s <uuid|filename>\n" + " [--newpassword <file>|-]\n" + " [--oldpassword <file>|-]\n" + " [--cipher <cipher identifier>]\n" + " [--newpasswordid <password identifier>]\n" + "\n", SEP); + + if (fCategory & USAGE_MEDIUMENCCHKPWD) + RTStrmPrintf(pStrm, + "%s checkmediumpwd %s <uuid|filename>\n" + " <pwd file>|-\n" + "\n", SEP); + + if (fCategory & USAGE_CONVERTFROMRAW) + RTStrmPrintf(pStrm, + "%s convertfromraw %s <filename> <outputfile>\n" + " [--format VDI|VMDK|VHD]\n" + " [--variant Standard,Fixed,Split2G,Stream,ESX]\n" + " [--uuid <uuid>]\n" + "%s convertfromraw %s stdin <outputfile> <bytes>\n" + " [--format VDI|VMDK|VHD]\n" + " [--variant Standard,Fixed,Split2G,Stream,ESX]\n" + " [--uuid <uuid>]\n" + "\n", SEP, SEP); + + if (fCategory & USAGE_GETEXTRADATA) + RTStrmPrintf(pStrm, + "%s getextradata %s global|<uuid|vmname>\n" + " <key>|[enumerate]\n" + "\n", SEP); + + if (fCategory & USAGE_SETEXTRADATA) + RTStrmPrintf(pStrm, + "%s setextradata %s global|<uuid|vmname>\n" + " <key>\n" + " [<value>] (no value deletes key)\n" + "\n", SEP); + + if (fCategory & USAGE_SETPROPERTY) + RTStrmPrintf(pStrm, + "%s setproperty %s machinefolder default|<folder> |\n" + " hwvirtexclusive on|off |\n" + " vrdeauthlibrary default|<library> |\n" + " websrvauthlibrary default|null|<library> |\n" + " vrdeextpack null|<library> |\n" + " autostartdbpath null|<folder> |\n" + " loghistorycount <value>\n" + " defaultfrontend default|<name>\n" + " logginglevel <log setting>\n" + " proxymode system|noproxy|manual\n" + " proxyurl <url>\n" + "\n", SEP); + + if (fCategory & USAGE_USBFILTER_ADD) + RTStrmPrintf(pStrm, + "%s usbfilter %s add <index,0-N>\n" + " --target <uuid|vmname>|global\n" + " --name <string>\n" + " --action ignore|hold (global filters only)\n" + " [--active yes|no] (yes)\n" + " [--vendorid <XXXX>] (null)\n" + " [--productid <XXXX>] (null)\n" + " [--revision <IIFF>] (null)\n" + " [--manufacturer <string>] (null)\n" + " [--product <string>] (null)\n" + " [--remote yes|no] (null, VM filters only)\n" + " [--serialnumber <string>] (null)\n" + " [--maskedinterfaces <XXXXXXXX>]\n" + "\n", SEP); + + if (fCategory & USAGE_USBFILTER_MODIFY) + RTStrmPrintf(pStrm, + "%s usbfilter %s modify <index,0-N>\n" + " --target <uuid|vmname>|global\n" + " [--name <string>]\n" + " [--action ignore|hold] (global filters only)\n" + " [--active yes|no]\n" + " [--vendorid <XXXX>|\"\"]\n" + " [--productid <XXXX>|\"\"]\n" + " [--revision <IIFF>|\"\"]\n" + " [--manufacturer <string>|\"\"]\n" + " [--product <string>|\"\"]\n" + " [--remote yes|no] (null, VM filters only)\n" + " [--serialnumber <string>|\"\"]\n" + " [--maskedinterfaces <XXXXXXXX>]\n" + "\n", SEP); + + if (fCategory & USAGE_USBFILTER_REMOVE) + RTStrmPrintf(pStrm, + "%s usbfilter %s remove <index,0-N>\n" + " --target <uuid|vmname>|global\n" + "\n", SEP); + + if (fCategory & USAGE_SHAREDFOLDER_ADD) + RTStrmPrintf(pStrm, + "%s sharedfolder %s add <uuid|vmname>\n" + " --name <name> --hostpath <hostpath>\n" + " [--transient] [--readonly] [--automount]\n" + "\n", SEP); + + if (fCategory & USAGE_SHAREDFOLDER_REMOVE) + RTStrmPrintf(pStrm, + "%s sharedfolder %s remove <uuid|vmname>\n" + " --name <name> [--transient]\n" + "\n", SEP); + +#ifdef VBOX_WITH_GUEST_PROPS + if (fCategory & USAGE_GUESTPROPERTY) + usageGuestProperty(pStrm, SEP); +#endif /* VBOX_WITH_GUEST_PROPS defined */ + +#ifdef VBOX_WITH_GUEST_CONTROL + if (fCategory & USAGE_GUESTCONTROL) + usageGuestControl(pStrm, SEP, fSubCategory); +#endif /* VBOX_WITH_GUEST_CONTROL defined */ + + if (fCategory & USAGE_METRICS) + RTStrmPrintf(pStrm, + "%s metrics %s list [*|host|<vmname> [<metric_list>]]\n" + " (comma-separated)\n\n" + "%s metrics %s setup\n" + " [--period <seconds>] (default: 1)\n" + " [--samples <count>] (default: 1)\n" + " [--list]\n" + " [*|host|<vmname> [<metric_list>]]\n\n" + "%s metrics %s query [*|host|<vmname> [<metric_list>]]\n\n" + "%s metrics %s enable\n" + " [--list]\n" + " [*|host|<vmname> [<metric_list>]]\n\n" + "%s metrics %s disable\n" + " [--list]\n" + " [*|host|<vmname> [<metric_list>]]\n\n" + "%s metrics %s collect\n" + " [--period <seconds>] (default: 1)\n" + " [--samples <count>] (default: 1)\n" + " [--list]\n" + " [--detach]\n" + " [*|host|<vmname> [<metric_list>]]\n" + "\n", SEP, SEP, SEP, SEP, SEP, SEP); + +#if defined(VBOX_WITH_NAT_SERVICE) + if (fCategory & USAGE_NATNETWORK) + { + RTStrmPrintf(pStrm, + "%s natnetwork %s add --netname <name>\n" + " --network <network>\n" + " [--enable|--disable]\n" + " [--dhcp on|off]\n" + " [--port-forward-4 <rule>]\n" + " [--loopback-4 <rule>]\n" + " [--ipv6 on|off]\n" + " [--port-forward-6 <rule>]\n" + " [--loopback-6 <rule>]\n\n" + "%s natnetwork %s remove --netname <name>\n\n" + "%s natnetwork %s modify --netname <name>\n" + " [--network <network>]\n" + " [--enable|--disable]\n" + " [--dhcp on|off]\n" + " [--port-forward-4 <rule>]\n" + " [--loopback-4 <rule>]\n" + " [--ipv6 on|off]\n" + " [--port-forward-6 <rule>]\n" + " [--loopback-6 <rule>]\n\n" + "%s natnetwork %s start --netname <name>\n\n" + "%s natnetwork %s stop --netname <name>\n\n" + "%s natnetwork %s list [<pattern>]\n" + "\n", SEP, SEP, SEP, SEP, SEP, SEP); + + + } +#endif + +#if defined(VBOX_WITH_NETFLT) + if (fCategory & USAGE_HOSTONLYIFS) + { + RTStrmPrintf(pStrm, + "%s hostonlyif %s ipconfig <name>\n" + " [--dhcp |\n" + " --ip<ipv4> [--netmask<ipv4> (def: 255.255.255.0)] |\n" + " --ipv6<ipv6> [--netmasklengthv6<length> (def: 64)]]\n" +# if !defined(RT_OS_SOLARIS) || defined(VBOX_ONLY_DOCS) + " create |\n" + " remove <name>\n" +# endif + "\n", SEP); + } +#endif + + if (fCategory & USAGE_DHCPSERVER) + { + RTStrmPrintf(pStrm, + "%s dhcpserver %s add|modify --netname <network_name> |\n" +#if defined(VBOX_WITH_NETFLT) + " --ifname <hostonly_if_name>\n" +#endif + " [--ip <ip_address>\n" + " --netmask <network_mask>\n" + " --lowerip <lower_ip>\n" + " --upperip <upper_ip>]\n" + " [--enable | --disable]\n" + " [--options [--vm <name> --nic <1-N>]\n" + " --id <number> [--value <string> | --remove]]\n" + " (multiple options allowed after --options)\n\n" + "%s dhcpserver %s remove --netname <network_name> |\n" +#if defined(VBOX_WITH_NETFLT) + " --ifname <hostonly_if_name>\n" +#endif + "\n", SEP, SEP); + } + + if (fCategory & USAGE_USBDEVSOURCE) + { + RTStrmPrintf(pStrm, + "%s usbdevsource %s add <source name>\n" + " --backend <backend>\n" + " --address <address>\n" + "%s usbdevsource %s remove <source name>\n" + "\n", SEP, SEP); + } + +#ifndef VBOX_ONLY_DOCS /* Converted to man page, not needed. */ + if (fCategory == USAGE_ALL) + { + uint32_t cPendingBlankLines = 0; + for (uint32_t i = 0; i < g_cHelpEntries; i++) + { + PCRTMSGREFENTRY pHelp = g_apHelpEntries[i]; + while (cPendingBlankLines-- > 0) + RTStrmPutCh(pStrm, '\n'); + RTStrmPrintf(pStrm, " %c%s:\n", RT_C_TO_UPPER(pHelp->pszBrief[0]), pHelp->pszBrief + 1); + cPendingBlankLines = 0; + RTMsgRefEntryPrintStringTable(pStrm, &pHelp->Synopsis, RTMSGREFENTRYSTR_SCOPE_GLOBAL, + &cPendingBlankLines, NULL /*pcLinesWritten*/); + cPendingBlankLines = RT_MAX(cPendingBlankLines, 1); + } + } +#endif +} + +/** + * Print a usage synopsis and the syntax error message. + * @returns RTEXITCODE_SYNTAX. + */ +RTEXITCODE errorSyntax(USAGECATEGORY fCategory, const char *pszFormat, ...) +{ + va_list args; + showLogo(g_pStdErr); // show logo even if suppressed +#ifndef VBOX_ONLY_DOCS + if (g_fInternalMode) + printUsageInternal(fCategory, g_pStdErr); + else + printUsage(fCategory, ~0U, g_pStdErr); +#else + RT_NOREF_PV(fCategory); +#endif + va_start(args, pszFormat); + RTStrmPrintf(g_pStdErr, "\nSyntax error: %N\n", pszFormat, &args); + va_end(args); + return RTEXITCODE_SYNTAX; +} + +/** + * Print a usage synopsis and the syntax error message. + * @returns RTEXITCODE_SYNTAX. + */ +RTEXITCODE errorSyntaxEx(USAGECATEGORY fCategory, uint32_t fSubCategory, const char *pszFormat, ...) +{ + va_list args; + showLogo(g_pStdErr); // show logo even if suppressed +#ifndef VBOX_ONLY_DOCS + if (g_fInternalMode) + printUsageInternal(fCategory, g_pStdErr); + else + printUsage(fCategory, fSubCategory, g_pStdErr); +#else + RT_NOREF2(fCategory, fSubCategory); +#endif + va_start(args, pszFormat); + RTStrmPrintf(g_pStdErr, "\nSyntax error: %N\n", pszFormat, &args); + va_end(args); + return RTEXITCODE_SYNTAX; +} + +/** + * errorSyntax for RTGetOpt users. + * + * @returns RTEXITCODE_SYNTAX. + * + * @param fCategory The usage category of the command. + * @param fSubCategory The usage sub-category of the command. + * @param rc The RTGetOpt return code. + * @param pValueUnion The value union. + */ +RTEXITCODE errorGetOptEx(USAGECATEGORY fCategory, uint32_t fSubCategory, int rc, union RTGETOPTUNION const *pValueUnion) +{ + /* + * Check if it is an unhandled standard option. + */ +#ifndef VBOX_ONLY_DOCS + if (rc == 'V') + { + RTPrintf("%sr%d\n", VBOX_VERSION_STRING, RTBldCfgRevision()); + return RTEXITCODE_SUCCESS; + } +#endif + + if (rc == 'h') + { + showLogo(g_pStdErr); +#ifndef VBOX_ONLY_DOCS + if (g_fInternalMode) + printUsageInternal(fCategory, g_pStdOut); + else + printUsage(fCategory, fSubCategory, g_pStdOut); +#endif + return RTEXITCODE_SUCCESS; + } + + /* + * General failure. + */ + showLogo(g_pStdErr); // show logo even if suppressed +#ifndef VBOX_ONLY_DOCS + if (g_fInternalMode) + printUsageInternal(fCategory, g_pStdErr); + else + printUsage(fCategory, fSubCategory, g_pStdErr); +#else + RT_NOREF2(fCategory, fSubCategory); +#endif + + if (rc == VINF_GETOPT_NOT_OPTION) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid parameter '%s'", pValueUnion->psz); + if (rc > 0) + { + if (RT_C_IS_PRINT(rc)) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid option -%c", rc); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid option case %i", rc); + } + if (rc == VERR_GETOPT_UNKNOWN_OPTION) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown option: %s", pValueUnion->psz); + if (rc == VERR_GETOPT_INVALID_ARGUMENT_FORMAT) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid argument format: %s", pValueUnion->psz); + if (pValueUnion->pDef) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%s: %Rrs", pValueUnion->pDef->pszLong, rc); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "%Rrs", rc); +} + +/** + * errorSyntax for RTGetOpt users. + * + * @returns RTEXITCODE_SYNTAX. + * + * @param fUsageCategory The usage category of the command. + * @param rc The RTGetOpt return code. + * @param pValueUnion The value union. + */ +RTEXITCODE errorGetOpt(USAGECATEGORY fCategory, int rc, union RTGETOPTUNION const *pValueUnion) +{ + return errorGetOptEx(fCategory, ~0U, rc, pValueUnion); +} + +/** + * Print an error message without the syntax stuff. + * + * @returns RTEXITCODE_SYNTAX. + */ +RTEXITCODE errorArgument(const char *pszFormat, ...) +{ + va_list args; + va_start(args, pszFormat); + RTMsgErrorV(pszFormat, args); + va_end(args); + return RTEXITCODE_SYNTAX; +} + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp new file mode 100644 index 00000000..401a80dc --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp @@ -0,0 +1,283 @@ +/* $Id: VBoxManageHostonly.cpp $ */ +/** @file + * VBoxManage - Implementation of hostonlyif command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/cidr.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/net.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> + +#include <VBox/log.h> + +#include "VBoxManage.h" + +#ifndef VBOX_ONLY_DOCS +using namespace com; + +static const RTGETOPTDEF g_aHostOnlyCreateOptions[] = +{ + { "--machinereadable", 'M', RTGETOPT_REQ_NOTHING }, +}; + +#if defined(VBOX_WITH_NETFLT) && !defined(RT_OS_SOLARIS) +static RTEXITCODE handleCreate(HandlerArg *a) +{ + /* + * Parse input. + */ + bool fMachineReadable = false; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, g_aHostOnlyCreateOptions, + RT_ELEMENTS(g_aHostOnlyCreateOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + int c; + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case 'M': // --machinereadable + fMachineReadable = true; + break; + + default: + return errorGetOpt(USAGE_HOSTONLYIFS, c, &ValueUnion); + } + } + + /* + * Do the work. + */ + ComPtr<IHost> host; + CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IHostNetworkInterface> hif; + ComPtr<IProgress> progress; + + CHECK_ERROR2I_RET(host, CreateHostOnlyNetworkInterface(hif.asOutParam(), progress.asOutParam()), RTEXITCODE_FAILURE); + + if (fMachineReadable) + { + CHECK_PROGRESS_ERROR_RET(progress, (""), RTEXITCODE_FAILURE); + } + else + { + /*HRESULT hrc =*/ showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Failed to create the host-only adapter"), RTEXITCODE_FAILURE); + } + + Bstr bstrName; + CHECK_ERROR2I(hif, COMGETTER(Name)(bstrName.asOutParam())); + + if (fMachineReadable) + RTPrintf("%ls", bstrName.raw()); + else + RTPrintf("Interface '%ls' was successfully created\n", bstrName.raw()); + return RTEXITCODE_SUCCESS; +} + +static RTEXITCODE handleRemove(HandlerArg *a) +{ + /* + * Parse input. + */ + const char *pszName = NULL; + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, NULL, 0, 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0) + switch (ch) + { + case VINF_GETOPT_NOT_OPTION: + if (pszName) + return errorSyntax(USAGE_HOSTONLYIFS, "Only one interface name can be specified"); + pszName = ValueUnion.psz; + break; + + default: + return errorGetOpt(USAGE_HOSTONLYIFS, ch, &ValueUnion); + } + if (!pszName) + return errorSyntax(USAGE_HOSTONLYIFS, "No interface name was specified"); + + /* + * Do the work. + */ + ComPtr<IHost> host; + CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IHostNetworkInterface> hif; + CHECK_ERROR2I_RET(host, FindHostNetworkInterfaceByName(Bstr(pszName).raw(), hif.asOutParam()), RTEXITCODE_FAILURE); + + Bstr guid; + CHECK_ERROR2I_RET(hif, COMGETTER(Id)(guid.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IProgress> progress; + CHECK_ERROR2I_RET(host, RemoveHostOnlyNetworkInterface(guid.raw(), progress.asOutParam()), RTEXITCODE_FAILURE); + + /*HRESULT hrc =*/ showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Failed to remove the host-only adapter"), RTEXITCODE_FAILURE); + + return RTEXITCODE_SUCCESS; +} +#endif + +static const RTGETOPTDEF g_aHostOnlyIPOptions[] + = { + { "--dhcp", 'd', RTGETOPT_REQ_NOTHING }, + { "-dhcp", 'd', RTGETOPT_REQ_NOTHING }, // deprecated + { "--ip", 'a', RTGETOPT_REQ_STRING }, + { "-ip", 'a', RTGETOPT_REQ_STRING }, // deprecated + { "--netmask", 'm', RTGETOPT_REQ_STRING }, + { "-netmask", 'm', RTGETOPT_REQ_STRING }, // deprecated + { "--ipv6", 'b', RTGETOPT_REQ_STRING }, + { "-ipv6", 'b', RTGETOPT_REQ_STRING }, // deprecated + { "--netmasklengthv6", 'l', RTGETOPT_REQ_UINT8 }, + { "-netmasklengthv6", 'l', RTGETOPT_REQ_UINT8 } // deprecated + }; + +static RTEXITCODE handleIpConfig(HandlerArg *a) +{ + bool fDhcp = false; + bool fNetmasklengthv6 = false; + uint32_t uNetmasklengthv6 = UINT32_MAX; + const char *pszIpv6 = NULL; + const char *pszIp = NULL; + const char *pszNetmask = NULL; + const char *pszName = NULL; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, g_aHostOnlyIPOptions, RT_ELEMENTS(g_aHostOnlyIPOptions), + 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case 'd': // --dhcp + fDhcp = true; + break; + case 'a': // --ip + if (pszIp) + RTMsgWarning("The --ip option is specified more than once"); + pszIp = ValueUnion.psz; + break; + case 'm': // --netmask + if (pszNetmask) + RTMsgWarning("The --netmask option is specified more than once"); + pszNetmask = ValueUnion.psz; + break; + case 'b': // --ipv6 + if (pszIpv6) + RTMsgWarning("The --ipv6 option is specified more than once"); + pszIpv6 = ValueUnion.psz; + break; + case 'l': // --netmasklengthv6 + if (fNetmasklengthv6) + RTMsgWarning("The --netmasklengthv6 option is specified more than once"); + fNetmasklengthv6 = true; + uNetmasklengthv6 = ValueUnion.u8; + break; + case VINF_GETOPT_NOT_OPTION: + if (pszName) + return errorSyntax(USAGE_HOSTONLYIFS, "Only one interface name can be specified"); + pszName = ValueUnion.psz; + break; + default: + return errorGetOpt(USAGE_HOSTONLYIFS, c, &ValueUnion); + } + } + + /* parameter sanity check */ + if (fDhcp && (fNetmasklengthv6 || pszIpv6 || pszIp || pszNetmask)) + return errorSyntax(USAGE_HOSTONLYIFS, "You can not use --dhcp with static ip configuration parameters: --ip, --netmask, --ipv6 and --netmasklengthv6."); + if ((pszIp || pszNetmask) && (fNetmasklengthv6 || pszIpv6)) + return errorSyntax(USAGE_HOSTONLYIFS, "You can not use ipv4 configuration (--ip and --netmask) with ipv6 (--ipv6 and --netmasklengthv6) simultaneously."); + + ComPtr<IHost> host; + CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IHostNetworkInterface> hif; + CHECK_ERROR2I_RET(host, FindHostNetworkInterfaceByName(Bstr(pszName).raw(), hif.asOutParam()), RTEXITCODE_FAILURE); + if (hif.isNull()) + return errorArgument("Could not find interface '%s'", pszName); + + if (fDhcp) + CHECK_ERROR2I_RET(hif, EnableDynamicIPConfig(), RTEXITCODE_FAILURE); + else if (pszIp) + { + if (!pszNetmask) + pszNetmask = "255.255.255.0"; /* ?? */ + CHECK_ERROR2I_RET(hif, EnableStaticIPConfig(Bstr(pszIp).raw(), Bstr(pszNetmask).raw()), RTEXITCODE_FAILURE); + } + else if (pszIpv6) + { + BOOL fIpV6Supported; + CHECK_ERROR2I_RET(hif, COMGETTER(IPV6Supported)(&fIpV6Supported), RTEXITCODE_FAILURE); + if (!fIpV6Supported) + { + RTMsgError("IPv6 setting is not supported for this adapter"); + return RTEXITCODE_FAILURE; + } + + if (uNetmasklengthv6 == UINT32_MAX) + uNetmasklengthv6 = 64; /* ?? */ + CHECK_ERROR2I_RET(hif, EnableStaticIPConfigV6(Bstr(pszIpv6).raw(), (ULONG)uNetmasklengthv6), RTEXITCODE_FAILURE); + } + else + return errorSyntax(USAGE_HOSTONLYIFS, "Neither -dhcp nor -ip nor -ipv6 was specfified"); + + return RTEXITCODE_SUCCESS; +} + + +RTEXITCODE handleHostonlyIf(HandlerArg *a) +{ + if (a->argc < 1) + return errorSyntax(USAGE_HOSTONLYIFS, "No sub-command specified"); + + RTEXITCODE rcExit; + if (!strcmp(a->argv[0], "ipconfig")) + rcExit = handleIpConfig(a); +#if defined(VBOX_WITH_NETFLT) && !defined(RT_OS_SOLARIS) + else if (!strcmp(a->argv[0], "create")) + rcExit = handleCreate(a); + else if (!strcmp(a->argv[0], "remove")) + rcExit = handleRemove(a); +#endif + else + rcExit = errorSyntax(USAGE_HOSTONLYIFS, "Unknown sub-command '%s'", a->argv[0]); + return rcExit; +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp new file mode 100644 index 00000000..afc489a3 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp @@ -0,0 +1,2691 @@ +/* $Id: VBoxManageInfo.cpp $ */ +/** @file + * VBoxManage - The 'showvminfo' command and helper routines. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> + +#include <VBox/com/VirtualBox.h> + +#ifdef VBOX_WITH_PCI_PASSTHROUGH +#include <VBox/pci.h> +#endif + +#include <VBox/log.h> +#include <VBox/version.h> +#include <iprt/stream.h> +#include <iprt/time.h> +#include <iprt/string.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> + +#include "VBoxManage.h" +using namespace com; + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + +/** + * Helper for formatting an indexed name or some such thing. + */ +static const char *FmtNm(char psz[80], const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + RTStrPrintfV(psz, 80, pszFormat, va); + va_end(va); + return psz; +} + +HRESULT showSnapshots(ComPtr<ISnapshot> &rootSnapshot, + ComPtr<ISnapshot> ¤tSnapshot, + VMINFO_DETAILS details, + const Utf8Str &prefix /* = ""*/, + int level /*= 0*/) +{ + /* start with the root */ + Bstr name; + Bstr uuid; + Bstr description; + CHECK_ERROR2I_RET(rootSnapshot, COMGETTER(Name)(name.asOutParam()), hrcCheck); + CHECK_ERROR2I_RET(rootSnapshot, COMGETTER(Id)(uuid.asOutParam()), hrcCheck); + CHECK_ERROR2I_RET(rootSnapshot, COMGETTER(Description)(description.asOutParam()), hrcCheck); + bool fCurrent = (rootSnapshot == currentSnapshot); + if (details == VMINFO_MACHINEREADABLE) + { + /* print with hierarchical numbering */ + RTPrintf("SnapshotName%s=\"%ls\"\n", prefix.c_str(), name.raw()); + RTPrintf("SnapshotUUID%s=\"%s\"\n", prefix.c_str(), Utf8Str(uuid).c_str()); + if (!description.isEmpty()) + RTPrintf("SnapshotDescription%s=\"%ls\"\n", prefix.c_str(), description.raw()); + if (fCurrent) + { + RTPrintf("CurrentSnapshotName=\"%ls\"\n", name.raw()); + RTPrintf("CurrentSnapshotUUID=\"%s\"\n", Utf8Str(uuid).c_str()); + RTPrintf("CurrentSnapshotNode=\"SnapshotName%s\"\n", prefix.c_str()); + } + } + else + { + /* print with indentation */ + RTPrintf(" %sName: %ls (UUID: %s)%s\n", + prefix.c_str(), + name.raw(), + Utf8Str(uuid).c_str(), + (fCurrent) ? " *" : ""); + if (!description.isEmpty()) + RTPrintf(" %sDescription:\n%ls\n", prefix.c_str(), description.raw()); + } + + /* get the children */ + HRESULT hrc = S_OK; + SafeIfaceArray <ISnapshot> coll; + CHECK_ERROR2I_RET(rootSnapshot,COMGETTER(Children)(ComSafeArrayAsOutParam(coll)), hrcCheck); + if (!coll.isNull()) + { + for (size_t index = 0; index < coll.size(); ++index) + { + ComPtr<ISnapshot> snapshot = coll[index]; + if (snapshot) + { + Utf8Str newPrefix; + if (details == VMINFO_MACHINEREADABLE) + newPrefix = Utf8StrFmt("%s-%d", prefix.c_str(), index + 1); + else + { + newPrefix = Utf8StrFmt("%s ", prefix.c_str()); + } + + /* recursive call */ + HRESULT hrc2 = showSnapshots(snapshot, currentSnapshot, details, newPrefix, level + 1); + if (FAILED(hrc2)) + hrc = hrc2; + } + } + } + return hrc; +} + +static void makeTimeStr(char *s, int cb, int64_t millies) +{ + RTTIME t; + RTTIMESPEC ts; + + RTTimeSpecSetMilli(&ts, millies); + + RTTimeExplode(&t, &ts); + + RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC", + t.i32Year, t.u8Month, t.u8MonthDay, + t.u8Hour, t.u8Minute, t.u8Second); +} + +const char *machineStateToName(MachineState_T machineState, bool fShort) +{ + switch (machineState) + { + case MachineState_PoweredOff: + return fShort ? "poweroff" : "powered off"; + case MachineState_Saved: + return "saved"; + case MachineState_Teleported: + return "teleported"; + case MachineState_Aborted: + return "aborted"; + case MachineState_Running: + return "running"; + case MachineState_Paused: + return "paused"; + case MachineState_Stuck: + return fShort ? "gurumeditation" : "guru meditation"; + case MachineState_Teleporting: + return "teleporting"; + case MachineState_LiveSnapshotting: + return fShort ? "livesnapshotting" : "live snapshotting"; + case MachineState_Starting: + return "starting"; + case MachineState_Stopping: + return "stopping"; + case MachineState_Saving: + return "saving"; + case MachineState_Restoring: + return "restoring"; + case MachineState_TeleportingPausedVM: + return fShort ? "teleportingpausedvm" : "teleporting paused vm"; + case MachineState_TeleportingIn: + return fShort ? "teleportingin" : "teleporting (incoming)"; + case MachineState_FaultTolerantSyncing: + return fShort ? "faulttolerantsyncing" : "fault tolerant syncing"; + case MachineState_DeletingSnapshotOnline: + return fShort ? "deletingsnapshotlive" : "deleting snapshot live"; + case MachineState_DeletingSnapshotPaused: + return fShort ? "deletingsnapshotlivepaused" : "deleting snapshot live paused"; + case MachineState_OnlineSnapshotting: + return fShort ? "onlinesnapshotting" : "online snapshotting"; + case MachineState_RestoringSnapshot: + return fShort ? "restoringsnapshot" : "restoring snapshot"; + case MachineState_DeletingSnapshot: + return fShort ? "deletingsnapshot" : "deleting snapshot"; + case MachineState_SettingUp: + return fShort ? "settingup" : "setting up"; + case MachineState_Snapshotting: + return fShort ? "snapshotting" : "offline snapshotting"; + default: + break; + } + return "unknown"; +} + +const char *facilityStateToName(AdditionsFacilityStatus_T faStatus, bool fShort) +{ + switch (faStatus) + { + case AdditionsFacilityStatus_Inactive: + return fShort ? "inactive" : "not active"; + case AdditionsFacilityStatus_Paused: + return "paused"; + case AdditionsFacilityStatus_PreInit: + return fShort ? "preinit" : "pre-initializing"; + case AdditionsFacilityStatus_Init: + return fShort ? "init" : "initializing"; + case AdditionsFacilityStatus_Active: + return fShort ? "active" : "active/running"; + case AdditionsFacilityStatus_Terminating: + return "terminating"; + case AdditionsFacilityStatus_Terminated: + return "terminated"; + case AdditionsFacilityStatus_Failed: + return "failed"; + case AdditionsFacilityStatus_Unknown: + default: + break; + } + return "unknown"; +} + +/** + * This takes care of escaping double quotes and slashes that the string might + * contain. + * + * @param pszName The variable name. + * @param pszValue The value. + */ +static void outputMachineReadableString(const char *pszName, const char *pszValue) +{ + Assert(strpbrk(pszName, "\"\\") == NULL); + + if ( !pszValue + || !*pszValue + || ( strchr(pszValue, '"') == NULL + && strchr(pszValue, '\\') == NULL) ) + RTPrintf("%s=\"%s\"\n", pszName, pszValue); + else + { + /* The value needs escaping. */ + RTPrintf("%s=\"", pszName); + const char *psz = pszValue; + for (;;) + { + const char *pszNext = strpbrk(psz, "\"\\"); + if (!pszNext) + { + RTPrintf("%s", psz); + break; + } + RTPrintf("%.*s\\%c", pszNext - psz, psz, *pszNext); + psz = pszNext + 1; + } + RTPrintf("\"\n"); + } +} + + +/** + * This takes care of escaping double quotes and slashes that the string might + * contain. + * + * @param pszName The variable name. + * @param pbstrValue The value. + */ +static void outputMachineReadableString(const char *pszName, Bstr const *pbstrValue) +{ + com::Utf8Str strValue(*pbstrValue); + outputMachineReadableString(pszName, strValue.c_str()); +} + +/** + * Converts bandwidth group type to a string. + * @returns String representation. + * @param enmType Bandwidth control group type. + */ +static const char * bwGroupTypeToString(BandwidthGroupType_T enmType) +{ + switch (enmType) + { + case BandwidthGroupType_Null: return "Null"; + case BandwidthGroupType_Disk: return "Disk"; + case BandwidthGroupType_Network: return "Network"; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case BandwidthGroupType_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + return "unknown"; +} + +HRESULT showBandwidthGroups(ComPtr<IBandwidthControl> &bwCtrl, + VMINFO_DETAILS details) +{ + int rc = S_OK; + SafeIfaceArray<IBandwidthGroup> bwGroups; + + CHECK_ERROR_RET(bwCtrl, GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups)), rc); + + if (bwGroups.size() && details != VMINFO_MACHINEREADABLE) + RTPrintf("\n\n"); + for (size_t i = 0; i < bwGroups.size(); i++) + { + Bstr strName; + LONG64 cMaxBytesPerSec; + BandwidthGroupType_T enmType; + + CHECK_ERROR_RET(bwGroups[i], COMGETTER(Name)(strName.asOutParam()), rc); + CHECK_ERROR_RET(bwGroups[i], COMGETTER(Type)(&enmType), rc); + CHECK_ERROR_RET(bwGroups[i], COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec), rc); + + const char *pszType = bwGroupTypeToString(enmType); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("BandwidthGroup%zu=%ls,%s,%lld\n", i, strName.raw(), pszType, cMaxBytesPerSec); + else + { + const char *pszUnits = ""; + LONG64 cBytes = cMaxBytesPerSec; + if (cBytes == 0) + { + RTPrintf("Name: '%ls', Type: %s, Limit: none (disabled)\n", strName.raw(), pszType); + continue; + } + else if (!(cBytes % _1G)) + { + pszUnits = "G"; + cBytes /= _1G; + } + else if (!(cBytes % _1M)) + { + pszUnits = "M"; + cBytes /= _1M; + } + else if (!(cBytes % _1K)) + { + pszUnits = "K"; + cBytes /= _1K; + } + const char *pszNetUnits = NULL; + if (enmType == BandwidthGroupType_Network) + { + /* + * We want to report network rate limit in bits/s, not bytes. + * Only if it cannot be express it in kilobits we will fall + * back to reporting it in bytes. + */ + LONG64 cBits = cMaxBytesPerSec; + if (!(cBits % 125)) + { + cBits /= 125; + pszNetUnits = "k"; + if (!(cBits % 1000000)) + { + cBits /= 1000000; + pszNetUnits = "g"; + } + else if (!(cBits % 1000)) + { + cBits /= 1000; + pszNetUnits = "m"; + } + RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbits/sec (%lld %sbytes/sec)\n", strName.raw(), pszType, cBits, pszNetUnits, cBytes, pszUnits); + } + } + if (!pszNetUnits) + RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbytes/sec\n", strName.raw(), pszType, cBytes, pszUnits); + } + } + if (details != VMINFO_MACHINEREADABLE) + RTPrintf(bwGroups.size() != 0 ? "\n" : "<none>\n\n"); + + return rc; +} + +/** Shows a shared folder. */ +static HRESULT showSharedFolder(ComPtr<ISharedFolder> &sf, VMINFO_DETAILS details, const char *pszDesc, + const char *pszMrInfix, size_t idxMr, bool fFirst) +{ + Bstr name, hostPath, bstrAutoMountPoint; + BOOL writable = FALSE, fAutoMount = FALSE; + CHECK_ERROR2I_RET(sf, COMGETTER(Name)(name.asOutParam()), hrcCheck); + CHECK_ERROR2I_RET(sf, COMGETTER(HostPath)(hostPath.asOutParam()), hrcCheck); + CHECK_ERROR2I_RET(sf, COMGETTER(Writable)(&writable), hrcCheck); + CHECK_ERROR2I_RET(sf, COMGETTER(AutoMount)(&fAutoMount), hrcCheck); + CHECK_ERROR2I_RET(sf, COMGETTER(AutoMountPoint)(bstrAutoMountPoint.asOutParam()), hrcCheck); + + if (fFirst && details != VMINFO_MACHINEREADABLE) + RTPrintf("\n\n"); + if (details == VMINFO_MACHINEREADABLE) + { + char szNm[80]; + outputMachineReadableString(FmtNm(szNm, "SharedFolderName%s%zu", pszMrInfix, idxMr), &name); + outputMachineReadableString(FmtNm(szNm, "SharedFolderPath%s%zu", pszMrInfix, idxMr), &hostPath); + } + else + { + RTPrintf("Name: '%ls', Host path: '%ls' (%s), %s%s", + name.raw(), hostPath.raw(), pszDesc, writable ? "writable" : "readonly", fAutoMount ? ", auto-mount" : ""); + if (bstrAutoMountPoint.isNotEmpty()) + RTPrintf(", mount-point: '%ls'\n", bstrAutoMountPoint.raw()); + else + RTPrintf("\n"); + } + return S_OK; +} + + +static const char *paravirtProviderToString(ParavirtProvider_T provider, VMINFO_DETAILS details) +{ + switch (provider) + { + case ParavirtProvider_None: + if (details == VMINFO_MACHINEREADABLE) + return "none"; + return "None"; + + case ParavirtProvider_Default: + if (details == VMINFO_MACHINEREADABLE) + return "default"; + return "Default"; + + case ParavirtProvider_Legacy: + if (details == VMINFO_MACHINEREADABLE) + return "legacy"; + return "Legacy"; + + case ParavirtProvider_Minimal: + if (details == VMINFO_MACHINEREADABLE) + return "minimal"; + return "Minimal"; + + case ParavirtProvider_HyperV: + if (details == VMINFO_MACHINEREADABLE) + return "hyperv"; + return "HyperV"; + + case ParavirtProvider_KVM: + if (details == VMINFO_MACHINEREADABLE) + return "kvm"; + return "KVM"; + + default: + if (details == VMINFO_MACHINEREADABLE) + return "unknown"; + return "Unknown"; + } +} + + +/* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable + time. MSC 7.1/32 doesn't have quite as much trouble with it, but still + sufficient to qualify for this hack as well since this code isn't performance + critical and probably won't gain much from the extra optimizing in real life. */ +#if defined(_MSC_VER) +# pragma optimize("g", off) +# pragma warning(push) +# if _MSC_VER < RT_MSC_VER_VC120 +# pragma warning(disable: 4748) +# endif +#endif + +HRESULT showVMInfo(ComPtr<IVirtualBox> pVirtualBox, + ComPtr<IMachine> machine, + ComPtr<ISession> pSession, + VMINFO_DETAILS details /*= VMINFO_NONE*/) +{ + HRESULT rc; + ComPtr<IConsole> pConsole; + if (pSession) + pSession->COMGETTER(Console)(pConsole.asOutParam()); + + char szNm[80]; + char szValue[256]; + +#define SHOW_UTF8_STRING(a_pszMachine, a_pszHuman, a_szValue) \ + do \ + { \ + Assert(a_pszHuman[strlen(a_pszHuman) - 1] == ':'); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, a_szValue); \ + else \ + RTPrintf("%-28s %s\n", a_pszHuman, a_szValue); \ + } while (0) + +#define SHOW_BSTR_STRING(a_pszMachine, a_pszHuman, a_bstrValue) \ + do \ + { \ + Assert(a_pszHuman[strlen(a_pszHuman) - 1] == ':'); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, &a_bstrValue); \ + else \ + RTPrintf("%-28s %ls\n", a_pszHuman, a_bstrValue.raw()); \ + } while (0) + +#define SHOW_BOOL_VALUE_EX(a_pszMachine, a_pszHuman, a_fValue, a_szTrue, a_szFalse) \ + do \ + { \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, a_fValue ? "on" : "off"); \ + else \ + RTPrintf("%-28s %s\n", a_pszHuman, a_fValue ? a_szTrue: a_szFalse); \ + } while (0) + +#define SHOW_BOOL_VALUE(a_pszMachine, a_pszHuman, a_fValue) \ + SHOW_BOOL_VALUE_EX(a_pszMachine, a_pszHuman, a_fValue, "enabled", "disabled") + +#define SHOW_ULONG_VALUE(a_pszMachine, a_pszHuman, a_uValue, a_pszUnit) \ + do \ + { \ + if (details == VMINFO_MACHINEREADABLE) \ + RTPrintf("%s=%u\n", a_pszMachine, a_uValue); \ + else \ + RTPrintf("%-28s %u%s\n", a_pszHuman, a_uValue, a_pszUnit); \ + } while (0) + +#define SHOW_LONG64_VALUE(a_pszMachine, a_pszHuman, a_llValue, a_pszUnit) \ + do \ + { \ + if (details == VMINFO_MACHINEREADABLE) \ + RTPrintf("%s=%lld\n", a_pszMachine, a_llValue); \ + else \ + RTPrintf("%-28s %lld%s\n", a_pszHuman, a_llValue, a_pszUnit); \ + } while (0) + +#define SHOW_BOOLEAN_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \ + SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_pszMachine, a_pszHuman, "enabled", "disabled") + +#define SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_szTrue, a_szFalse) \ + do \ + { \ + BOOL f; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(&f), hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, f ? "on" : "off"); \ + else \ + RTPrintf("%-28s %s\n", a_pszHuman, f ? a_szTrue : a_szFalse); \ + } while (0) + +#define SHOW_BOOLEAN_METHOD(a_pObj, a_Invocation, a_pszMachine, a_pszHuman) \ + do \ + { \ + BOOL f; \ + CHECK_ERROR2I_RET(a_pObj, a_Invocation, hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, f ? "on" : "off"); \ + else \ + RTPrintf("%-28s %s\n", a_pszHuman, f ? "enabled" : "disabled"); \ + } while (0) + +#define SHOW_STRING_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \ + do \ + { \ + Bstr bstr; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(bstr.asOutParam()), hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, &bstr); \ + else \ + RTPrintf("%-28s %ls\n", a_pszHuman, bstr.raw()); \ + } while (0) + +#define SHOW_STRING_PROP_NOT_EMPTY(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \ + do \ + { \ + Bstr bstr; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(bstr.asOutParam()), hrcCheck); \ + if (bstr.isNotEmpty()) \ + { \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, &bstr); \ + else \ + RTPrintf("%-28s %ls\n", a_pszHuman, bstr.raw()); \ + } \ + } while (0) + + /** @def SHOW_STRING_PROP_MAJ + * For not breaking the output in a dot release we don't show default values. */ +#define SHOW_STRING_PROP_MAJ(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_pszUnless, a_uMajorVer) \ + do \ + { \ + Bstr bstr; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(bstr.asOutParam()), hrcCheck); \ + if ((a_uMajorVer) <= VBOX_VERSION_MAJOR || !bstr.equals(a_pszUnless)) \ + { \ + if (details == VMINFO_MACHINEREADABLE)\ + outputMachineReadableString(a_pszMachine, &bstr); \ + else \ + RTPrintf("%-28s %ls\n", a_pszHuman, bstr.raw()); \ + } \ + } while (0) + +#define SHOW_STRINGARRAY_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \ + do \ + { \ + SafeArray<BSTR> array; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(ComSafeArrayAsOutParam(array)), hrcCheck); \ + Utf8Str str; \ + for (size_t i = 0; i < array.size(); i++) \ + { \ + if (i != 0) \ + str.append(","); \ + str.append(Utf8Str(array[i]).c_str()); \ + } \ + Bstr bstr(str); \ + if (details == VMINFO_MACHINEREADABLE) \ + outputMachineReadableString(a_pszMachine, &bstr); \ + else \ + RTPrintf("%-28s %ls\n", a_pszHuman, bstr.raw()); \ + } while (0) + +#define SHOW_UUID_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) \ + SHOW_STRING_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman) + +#define SHOW_USHORT_PROP_EX2(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_pszUnit, a_szFmtMachine, a_szFmtHuman) \ + do \ + { \ + USHORT u16 = 0; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(&u16), hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + RTPrintf("%s=" a_szFmtMachine "\n", a_pszMachine, u16); \ + else \ + RTPrintf("%-28s " a_szFmtHuman "%s\n", a_pszHuman, u16, u16, a_pszUnit); \ + } while (0) + +#define SHOW_ULONG_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_pszUnit) \ + do \ + { \ + ULONG u32 = 0; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(&u32), hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + RTPrintf("%s=%u\n", a_pszMachine, u32); \ + else \ + RTPrintf("%-28s %u%s\n", a_pszHuman, u32, a_pszUnit); \ + } while (0) + +#define SHOW_LONG64_PROP(a_pObj, a_Prop, a_pszMachine, a_pszHuman, a_pszUnit) \ + do \ + { \ + LONG64 i64 = 0; \ + CHECK_ERROR2I_RET(a_pObj, COMGETTER(a_Prop)(&i64), hrcCheck); \ + if (details == VMINFO_MACHINEREADABLE) \ + RTPrintf("%s=%lld\n", a_pszMachine, i64); \ + else \ + RTPrintf("%-28s %'lld%s\n", a_pszHuman, i64, a_pszUnit); \ + } while (0) + + /* + * The rules for output in -argdump format: + * 1) the key part (the [0-9a-zA-Z_\-]+ string before the '=' delimiter) + * is all lowercase for "VBoxManage modifyvm" parameters. Any + * other values printed are in CamelCase. + * 2) strings (anything non-decimal) are printed surrounded by + * double quotes '"'. If the strings themselves contain double + * quotes, these characters are escaped by '\'. Any '\' character + * in the original string is also escaped by '\'. + * 3) numbers (containing just [0-9\-]) are written out unchanged. + */ + + BOOL fAccessible; + CHECK_ERROR2I_RET(machine, COMGETTER(Accessible)(&fAccessible), hrcCheck); + if (!fAccessible) + { + Bstr uuid; + machine->COMGETTER(Id)(uuid.asOutParam()); + if (details == VMINFO_COMPACT) + RTPrintf("\"<inaccessible>\" {%s}\n", Utf8Str(uuid).c_str()); + else + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("name=\"<inaccessible>\"\n"); + else + RTPrintf("Name: <inaccessible!>\n"); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).c_str()); + else + RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str()); + if (details != VMINFO_MACHINEREADABLE) + { + Bstr settingsFilePath; + rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam()); + RTPrintf("Config file: %ls\n", settingsFilePath.raw()); + ComPtr<IVirtualBoxErrorInfo> accessError; + rc = machine->COMGETTER(AccessError)(accessError.asOutParam()); + RTPrintf("Access error details:\n"); + ErrorInfo ei(accessError); + GluePrintErrorInfo(ei); + RTPrintf("\n"); + } + } + return S_OK; + } + + if (details == VMINFO_COMPACT) + { + Bstr machineName; + machine->COMGETTER(Name)(machineName.asOutParam()); + Bstr uuid; + machine->COMGETTER(Id)(uuid.asOutParam()); + + RTPrintf("\"%ls\" {%s}\n", machineName.raw(), Utf8Str(uuid).c_str()); + return S_OK; + } + + SHOW_STRING_PROP( machine, Name, "name", "Name:"); + SHOW_STRINGARRAY_PROP( machine, Groups, "groups", "Groups:"); + Bstr osTypeId; + CHECK_ERROR2I_RET(machine, COMGETTER(OSTypeId)(osTypeId.asOutParam()), hrcCheck); + ComPtr<IGuestOSType> osType; + pVirtualBox->GetGuestOSType(osTypeId.raw(), osType.asOutParam()); + if (!osType.isNull()) + SHOW_STRING_PROP( osType, Description, "ostype", "Guest OS:"); + else + SHOW_STRING_PROP( machine, OSTypeId, "ostype", "Guest OS:"); + SHOW_UUID_PROP( machine, Id, "UUID", "UUID:"); + SHOW_STRING_PROP( machine, SettingsFilePath, "CfgFile", "Config file:"); + SHOW_STRING_PROP( machine, SnapshotFolder, "SnapFldr", "Snapshot folder:"); + SHOW_STRING_PROP( machine, LogFolder, "LogFldr", "Log folder:"); + SHOW_UUID_PROP( machine, HardwareUUID, "hardwareuuid", "Hardware UUID:"); + SHOW_ULONG_PROP( machine, MemorySize, "memory", "Memory size", "MB"); + SHOW_BOOLEAN_PROP( machine, PageFusionEnabled, "pagefusion", "Page Fusion:"); + SHOW_ULONG_PROP( machine, VRAMSize, "vram", "VRAM size:", "MB"); + SHOW_ULONG_PROP( machine, CPUExecutionCap, "cpuexecutioncap", "CPU exec cap:", "%"); + SHOW_BOOLEAN_PROP( machine, HPETEnabled, "hpet", "HPET:"); + SHOW_STRING_PROP_MAJ( machine, CPUProfile, "cpu-profile", "CPUProfile:", "host", 6); + + ChipsetType_T chipsetType; + CHECK_ERROR2I_RET(machine, COMGETTER(ChipsetType)(&chipsetType), hrcCheck); + const char *pszChipsetType; + switch (chipsetType) + { + case ChipsetType_Null: pszChipsetType = "invalid"; break; + case ChipsetType_PIIX3: pszChipsetType = "piix3"; break; + case ChipsetType_ICH9: pszChipsetType = "ich9"; break; + default: AssertFailed(); pszChipsetType = "unknown"; break; + } + SHOW_UTF8_STRING("chipset", "Chipset:", pszChipsetType); + + FirmwareType_T firmwareType; + CHECK_ERROR2I_RET(machine, COMGETTER(FirmwareType)(&firmwareType), hrcCheck); + const char *pszFirmwareType; + switch (firmwareType) + { + case FirmwareType_BIOS: pszFirmwareType = "BIOS"; break; + case FirmwareType_EFI: pszFirmwareType = "EFI"; break; + case FirmwareType_EFI32: pszFirmwareType = "EFI32"; break; + case FirmwareType_EFI64: pszFirmwareType = "EFI64"; break; + case FirmwareType_EFIDUAL: pszFirmwareType = "EFIDUAL"; break; + default: AssertFailed(); pszFirmwareType = "unknown"; break; + } + SHOW_UTF8_STRING("firmware", "Firmware:", pszFirmwareType); + + SHOW_ULONG_PROP( machine, CPUCount, "cpus", "Number of CPUs:", ""); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_PAE, &f), "pae", "PAE:"); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_LongMode, &f), "longmode", "Long Mode:"); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_TripleFaultReset, &f), "triplefaultreset", "Triple Fault Reset:"); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_APIC, &f), "apic", "APIC:"); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_X2APIC, &f), "x2apic", "X2APIC:"); + SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_HWVirt, &f), "nested-hw-virt", "Nested VT-x/AMD-V:"); + SHOW_ULONG_PROP( machine, CPUIDPortabilityLevel, "cpuid-portability-level", "CPUID Portability Level:", ""); + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("%-28s ", "CPUID overrides:"); + ULONG uOrdinal = 0; + for (uOrdinal = 0; uOrdinal < _4K; uOrdinal++) + { + ULONG uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX; + rc = machine->GetCPUIDLeafByOrdinal(uOrdinal, &uLeaf, &uSubLeaf, &uEAX, &uEBX, &uECX, &uEDX); + if (SUCCEEDED(rc)) + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x,%08x", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX); + else + { + if (!uOrdinal) + RTPrintf("Leaf no. EAX EBX ECX EDX\n"); + RTPrintf("%-28s %08x/%03x %08x %08x %08x %08x\n", "", uLeaf, uSubLeaf, uEAX, uEBX, uECX, uEDX); + } + } + else + { + if (rc != E_INVALIDARG) + com::GlueHandleComError(machine, "GetCPUIDLeaf", rc, __FILE__, __LINE__); + break; + } + } + if (!uOrdinal && details != VMINFO_MACHINEREADABLE) + RTPrintf("None\n"); + + ComPtr<IBIOSSettings> biosSettings; + CHECK_ERROR2I_RET(machine, COMGETTER(BIOSSettings)(biosSettings.asOutParam()), hrcCheck); + + BIOSBootMenuMode_T bootMenuMode; + CHECK_ERROR2I_RET(biosSettings, COMGETTER(BootMenuMode)(&bootMenuMode), hrcCheck); + const char *pszBootMenu; + switch (bootMenuMode) + { + case BIOSBootMenuMode_Disabled: + pszBootMenu = "disabled"; + break; + case BIOSBootMenuMode_MenuOnly: + if (details == VMINFO_MACHINEREADABLE) + pszBootMenu = "menuonly"; + else + pszBootMenu = "menu only"; + break; + default: + if (details == VMINFO_MACHINEREADABLE) + pszBootMenu = "messageandmenu"; + else + pszBootMenu = "message and menu"; + } + SHOW_UTF8_STRING("bootmenu", "Boot menu mode:", pszBootMenu); + + ComPtr<ISystemProperties> systemProperties; + CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck); + ULONG maxBootPosition = 0; + CHECK_ERROR2I_RET(systemProperties, COMGETTER(MaxBootPosition)(&maxBootPosition), hrcCheck); + for (ULONG i = 1; i <= maxBootPosition; i++) + { + DeviceType_T bootOrder; + CHECK_ERROR2I_RET(machine, GetBootOrder(i, &bootOrder), hrcCheck); + const char *pszDevice; + if (bootOrder == DeviceType_Floppy) + pszDevice = details == VMINFO_MACHINEREADABLE ? "floppy" : "Floppy"; + else if (bootOrder == DeviceType_DVD) + pszDevice = details == VMINFO_MACHINEREADABLE ? "dvd" : "DVD"; + else if (bootOrder == DeviceType_HardDisk) + pszDevice = details == VMINFO_MACHINEREADABLE ? "disk" : "HardDisk"; + else if (bootOrder == DeviceType_Network) + pszDevice = details == VMINFO_MACHINEREADABLE ? "net" : "Network"; + else if (bootOrder == DeviceType_USB) + pszDevice = details == VMINFO_MACHINEREADABLE ? "usb" : "USB"; + else if (bootOrder == DeviceType_SharedFolder) + pszDevice = details == VMINFO_MACHINEREADABLE ? "sharedfolder" : "Shared Folder"; + else + pszDevice = details == VMINFO_MACHINEREADABLE ? "none" : "Not Assigned"; + SHOW_UTF8_STRING(FmtNm(szNm, "boot%u", i), FmtNm(szNm, "Boot Device %u:", i), pszDevice); + } + + SHOW_BOOLEAN_PROP(biosSettings, ACPIEnabled, "acpi", "ACPI:"); + SHOW_BOOLEAN_PROP(biosSettings, IOAPICEnabled, "ioapic", "IOAPIC:"); + + APICMode_T apicMode; + CHECK_ERROR2I_RET(biosSettings, COMGETTER(APICMode)(&apicMode), hrcCheck); + const char *pszAPIC; + switch (apicMode) + { + case APICMode_Disabled: + pszAPIC = "disabled"; + break; + case APICMode_APIC: + default: + if (details == VMINFO_MACHINEREADABLE) + pszAPIC = "apic"; + else + pszAPIC = "APIC"; + break; + case APICMode_X2APIC: + if (details == VMINFO_MACHINEREADABLE) + pszAPIC = "x2apic"; + else + pszAPIC = "x2APIC"; + break; + } + SHOW_UTF8_STRING("biosapic", "BIOS APIC mode:", pszAPIC); + + SHOW_LONG64_PROP(biosSettings, TimeOffset, "biossystemtimeoffset", "Time offset:", "ms"); + SHOW_BOOLEAN_PROP_EX(machine, RTCUseUTC, "rtcuseutc", "RTC:", "UTC", "local time"); + SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &f), "hwvirtex", "Hardw. virt.ext:"); + SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", "Nested Paging:"); + SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f), "largepages", "Large Pages:"); + SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VPID, &f), "vtxvpid", "VT-x VPID:"); + SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", "VT-x unr. exec.:"); + + ParavirtProvider_T paravirtProvider; + CHECK_ERROR2I_RET(machine, COMGETTER(ParavirtProvider)(¶virtProvider), hrcCheck); + const char *pszParavirtProvider = paravirtProviderToString(paravirtProvider, details); + SHOW_UTF8_STRING("paravirtprovider", "Paravirt. Provider:", pszParavirtProvider); + + ParavirtProvider_T effParavirtProvider; + CHECK_ERROR2I_RET(machine, GetEffectiveParavirtProvider(&effParavirtProvider), hrcCheck); + const char *pszEffParavirtProvider = paravirtProviderToString(effParavirtProvider, details); + SHOW_UTF8_STRING("effparavirtprovider", "Effective Paravirt. Prov.:", pszEffParavirtProvider); + + Bstr paravirtDebug; + CHECK_ERROR2I_RET(machine, COMGETTER(ParavirtDebug)(paravirtDebug.asOutParam()), hrcCheck); + if (paravirtDebug.isNotEmpty()) + SHOW_BSTR_STRING("paravirtdebug", "Paravirt. Debug:", paravirtDebug); + + MachineState_T machineState; + CHECK_ERROR2I_RET(machine, COMGETTER(State)(&machineState), hrcCheck); + const char *pszState = machineStateToName(machineState, details == VMINFO_MACHINEREADABLE /*=fShort*/); + + LONG64 stateSince; + machine->COMGETTER(LastStateChange)(&stateSince); + RTTIMESPEC timeSpec; + RTTimeSpecSetMilli(&timeSpec, stateSince); + char pszTime[30] = {0}; + RTTimeSpecToString(&timeSpec, pszTime, sizeof(pszTime)); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("VMState=\"%s\"\n", pszState); + RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime); + + Bstr stateFile; + machine->COMGETTER(StateFilePath)(stateFile.asOutParam()); + if (!stateFile.isEmpty()) + RTPrintf("VMStateFile=\"%ls\"\n", stateFile.raw()); + } + else + RTPrintf("%-28s %s (since %s)\n", "State:", pszState, pszTime); + + SHOW_ULONG_PROP( machine, MonitorCount, "monitorcount", "Monitor count:", ""); + SHOW_BOOLEAN_PROP( machine, Accelerate3DEnabled, "accelerate3d", "3D Acceleration:"); +#ifdef VBOX_WITH_VIDEOHWACCEL + SHOW_BOOLEAN_PROP( machine, Accelerate2DVideoEnabled, "accelerate2dvideo", "2D Video Acceleration:"); +#endif + SHOW_BOOLEAN_PROP( machine, TeleporterEnabled, "teleporterenabled", "Teleporter Enabled:"); + SHOW_ULONG_PROP( machine, TeleporterPort, "teleporterport", "Teleporter Port:", ""); + SHOW_STRING_PROP( machine, TeleporterAddress, "teleporteraddress", "Teleporter Address:"); + SHOW_STRING_PROP( machine, TeleporterPassword, "teleporterpassword", "Teleporter Password:"); + SHOW_BOOLEAN_PROP( machine, TracingEnabled, "tracing-enabled", "Tracing Enabled:"); + SHOW_BOOLEAN_PROP( machine, AllowTracingToAccessVM, "tracing-allow-vm-access", "Allow Tracing to Access VM:"); + SHOW_STRING_PROP( machine, TracingConfig, "tracing-config", "Tracing Configuration:"); + SHOW_BOOLEAN_PROP( machine, AutostartEnabled, "autostart-enabled", "Autostart Enabled:"); + SHOW_ULONG_PROP( machine, AutostartDelay, "autostart-delay", "Autostart Delay:", ""); + SHOW_STRING_PROP( machine, DefaultFrontend, "defaultfrontend", "Default Frontend:"); + +/** @todo Convert the remainder of the function to SHOW_XXX macros and add error + * checking where missing. */ + /* + * Storage Controllers and their attached Mediums. + */ + com::SafeIfaceArray<IStorageController> storageCtls; + CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(storageCtls))); + for (size_t i = 0; i < storageCtls.size(); ++ i) + { + ComPtr<IStorageController> storageCtl = storageCtls[i]; + StorageControllerType_T enmCtlType = StorageControllerType_Null; + const char *pszCtl = NULL; + ULONG ulValue = 0; + BOOL fBootable = FALSE; + Bstr storageCtlName; + + storageCtl->COMGETTER(Name)(storageCtlName.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollername%u=\"%ls\"\n", i, storageCtlName.raw()); + else + RTPrintf("Storage Controller Name (%u): %ls\n", i, storageCtlName.raw()); + + storageCtl->COMGETTER(ControllerType)(&enmCtlType); + switch (enmCtlType) + { + case StorageControllerType_LsiLogic: + pszCtl = "LsiLogic"; + break; + case StorageControllerType_LsiLogicSas: + pszCtl = "LsiLogicSas"; + break; + case StorageControllerType_BusLogic: + pszCtl = "BusLogic"; + break; + case StorageControllerType_IntelAhci: + pszCtl = "IntelAhci"; + break; + case StorageControllerType_PIIX3: + pszCtl = "PIIX3"; + break; + case StorageControllerType_PIIX4: + pszCtl = "PIIX4"; + break; + case StorageControllerType_ICH6: + pszCtl = "ICH6"; + break; + case StorageControllerType_I82078: + pszCtl = "I82078"; + break; + case StorageControllerType_USB: + pszCtl = "USB"; + break; + + default: + pszCtl = "unknown"; + } + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollertype%u=\"%s\"\n", i, pszCtl); + else + RTPrintf("Storage Controller Type (%u): %s\n", i, pszCtl); + + storageCtl->COMGETTER(Instance)(&ulValue); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollerinstance%u=\"%lu\"\n", i, ulValue); + else + RTPrintf("Storage Controller Instance Number (%u): %lu\n", i, ulValue); + + storageCtl->COMGETTER(MaxPortCount)(&ulValue); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollermaxportcount%u=\"%lu\"\n", i, ulValue); + else + RTPrintf("Storage Controller Max Port Count (%u): %lu\n", i, ulValue); + + storageCtl->COMGETTER(PortCount)(&ulValue); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollerportcount%u=\"%lu\"\n", i, ulValue); + else + RTPrintf("Storage Controller Port Count (%u): %lu\n", i, ulValue); + + storageCtl->COMGETTER(Bootable)(&fBootable); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("storagecontrollerbootable%u=\"%s\"\n", i, fBootable ? "on" : "off"); + else + RTPrintf("Storage Controller Bootable (%u): %s\n", i, fBootable ? "on" : "off"); + } + + for (size_t j = 0; j < storageCtls.size(); ++ j) + { + ComPtr<IStorageController> storageCtl = storageCtls[j]; + ComPtr<IMedium> medium; + Bstr storageCtlName; + Bstr filePath; + ULONG cDevices; + ULONG cPorts; + + storageCtl->COMGETTER(Name)(storageCtlName.asOutParam()); + storageCtl->COMGETTER(MaxDevicesPerPortCount)(&cDevices); + storageCtl->COMGETTER(PortCount)(&cPorts); + + for (ULONG i = 0; i < cPorts; ++ i) + { + for (ULONG k = 0; k < cDevices; ++ k) + { + ComPtr<IMediumAttachment> mediumAttach; + machine->GetMediumAttachment(storageCtlName.raw(), + i, k, + mediumAttach.asOutParam()); + BOOL fIsEjected = FALSE; + BOOL fTempEject = FALSE; + DeviceType_T devType = DeviceType_Null; + if (mediumAttach) + { + mediumAttach->COMGETTER(TemporaryEject)(&fTempEject); + mediumAttach->COMGETTER(IsEjected)(&fIsEjected); + mediumAttach->COMGETTER(Type)(&devType); + } + rc = machine->GetMedium(storageCtlName.raw(), i, k, + medium.asOutParam()); + if (SUCCEEDED(rc) && medium) + { + BOOL fPassthrough = FALSE; + + if (mediumAttach) + mediumAttach->COMGETTER(Passthrough)(&fPassthrough); + + medium->COMGETTER(Location)(filePath.asOutParam()); + Bstr uuid; + medium->COMGETTER(Id)(uuid.asOutParam()); + + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("\"%ls-%d-%d\"=\"%ls\"\n", storageCtlName.raw(), + i, k, filePath.raw()); + RTPrintf("\"%ls-ImageUUID-%d-%d\"=\"%s\"\n", + storageCtlName.raw(), i, k, Utf8Str(uuid).c_str()); + if (fPassthrough) + RTPrintf("\"%ls-dvdpassthrough\"=\"%s\"\n", storageCtlName.raw(), + fPassthrough ? "on" : "off"); + if (devType == DeviceType_DVD) + { + RTPrintf("\"%ls-tempeject\"=\"%s\"\n", storageCtlName.raw(), + fTempEject ? "on" : "off"); + RTPrintf("\"%ls-IsEjected\"=\"%s\"\n", storageCtlName.raw(), + fIsEjected ? "on" : "off"); + } + } + else + { + RTPrintf("%ls (%d, %d): %ls (UUID: %s)", + storageCtlName.raw(), i, k, filePath.raw(), + Utf8Str(uuid).c_str()); + if (fPassthrough) + RTPrintf(" (passthrough enabled)"); + if (fTempEject) + RTPrintf(" (temp eject)"); + if (fIsEjected) + RTPrintf(" (ejected)"); + RTPrintf("\n"); + } + } + else if (SUCCEEDED(rc)) + { + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("\"%ls-%d-%d\"=\"emptydrive\"\n", storageCtlName.raw(), i, k); + if (devType == DeviceType_DVD) + RTPrintf("\"%ls-IsEjected\"=\"%s\"\n", storageCtlName.raw(), + fIsEjected ? "on" : "off"); + } + else + { + RTPrintf("%ls (%d, %d): Empty", storageCtlName.raw(), i, k); + if (fTempEject) + RTPrintf(" (temp eject)"); + if (fIsEjected) + RTPrintf(" (ejected)"); + RTPrintf("\n"); + } + } + else + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("\"%ls-%d-%d\"=\"none\"\n", storageCtlName.raw(), i, k); + } + } + } + } + + /* get the maximum amount of NICS */ + ULONG maxNICs = getMaxNics(pVirtualBox, machine); + + for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++) + { + ComPtr<INetworkAdapter> nic; + rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam()); + if (SUCCEEDED(rc) && nic) + { + FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "nic%u" : "NIC %u:", currentNIC + 1); + + BOOL fEnabled; + nic->COMGETTER(Enabled)(&fEnabled); + if (!fEnabled) + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("%s=\"none\"\n", szNm); + else + RTPrintf("%-28s disabled\n", szNm); + } + else + { + Bstr strMACAddress; + nic->COMGETTER(MACAddress)(strMACAddress.asOutParam()); + Utf8Str strAttachment; + Utf8Str strNatSettings = ""; + Utf8Str strNatForwardings = ""; + NetworkAttachmentType_T attachment; + nic->COMGETTER(AttachmentType)(&attachment); + switch (attachment) + { + case NetworkAttachmentType_Null: + if (details == VMINFO_MACHINEREADABLE) + strAttachment = "null"; + else + strAttachment = "none"; + break; + + case NetworkAttachmentType_NAT: + { + Bstr strNetwork; + ComPtr<INATEngine> engine; + nic->COMGETTER(NATEngine)(engine.asOutParam()); + engine->COMGETTER(Network)(strNetwork.asOutParam()); + com::SafeArray<BSTR> forwardings; + engine->COMGETTER(Redirects)(ComSafeArrayAsOutParam(forwardings)); + strNatForwardings = ""; + for (size_t i = 0; i < forwardings.size(); ++i) + { + bool fSkip = false; + BSTR r = forwardings[i]; + Utf8Str utf = Utf8Str(r); + Utf8Str strName; + Utf8Str strProto; + Utf8Str strHostPort; + Utf8Str strHostIP; + Utf8Str strGuestPort; + Utf8Str strGuestIP; + size_t pos, ppos; + pos = ppos = 0; + #define ITERATE_TO_NEXT_TERM(res, str, pos, ppos) \ + do { \ + pos = str.find(",", ppos); \ + if (pos == Utf8Str::npos) \ + { \ + Log(( #res " extracting from %s is failed\n", str.c_str())); \ + fSkip = true; \ + } \ + res = str.substr(ppos, pos - ppos); \ + Log2((#res " %s pos:%d, ppos:%d\n", res.c_str(), pos, ppos)); \ + ppos = pos + 1; \ + } while (0) + ITERATE_TO_NEXT_TERM(strName, utf, pos, ppos); + if (fSkip) continue; + ITERATE_TO_NEXT_TERM(strProto, utf, pos, ppos); + if (fSkip) continue; + ITERATE_TO_NEXT_TERM(strHostIP, utf, pos, ppos); + if (fSkip) continue; + ITERATE_TO_NEXT_TERM(strHostPort, utf, pos, ppos); + if (fSkip) continue; + ITERATE_TO_NEXT_TERM(strGuestIP, utf, pos, ppos); + if (fSkip) continue; + strGuestPort = utf.substr(ppos, utf.length() - ppos); + #undef ITERATE_TO_NEXT_TERM + switch (strProto.toUInt32()) + { + case NATProtocol_TCP: + strProto = "tcp"; + break; + case NATProtocol_UDP: + strProto = "udp"; + break; + default: + strProto = "unk"; + break; + } + if (details == VMINFO_MACHINEREADABLE) + { + strNatForwardings = Utf8StrFmt("%sForwarding(%d)=\"%s,%s,%s,%s,%s,%s\"\n", + strNatForwardings.c_str(), i, strName.c_str(), strProto.c_str(), + strHostIP.c_str(), strHostPort.c_str(), + strGuestIP.c_str(), strGuestPort.c_str()); + } + else + { + strNatForwardings = Utf8StrFmt("%sNIC %d Rule(%d): name = %s, protocol = %s," + " host ip = %s, host port = %s, guest ip = %s, guest port = %s\n", + strNatForwardings.c_str(), currentNIC + 1, i, strName.c_str(), strProto.c_str(), + strHostIP.c_str(), strHostPort.c_str(), + strGuestIP.c_str(), strGuestPort.c_str()); + } + } + ULONG mtu = 0; + ULONG sockSnd = 0; + ULONG sockRcv = 0; + ULONG tcpSnd = 0; + ULONG tcpRcv = 0; + engine->GetNetworkSettings(&mtu, &sockSnd, &sockRcv, &tcpSnd, &tcpRcv); + +/** @todo r=klaus dnsproxy etc needs to be dumped, too */ + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("natnet%d=\"%ls\"\n", currentNIC + 1, strNetwork.length() ? strNetwork.raw(): Bstr("nat").raw()); + strAttachment = "nat"; + strNatSettings = Utf8StrFmt("mtu=\"%d\"\nsockSnd=\"%d\"\nsockRcv=\"%d\"\ntcpWndSnd=\"%d\"\ntcpWndRcv=\"%d\"\n", + mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64, tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64); + } + else + { + strAttachment = "NAT"; + strNatSettings = Utf8StrFmt("NIC %d Settings: MTU: %d, Socket (send: %d, receive: %d), TCP Window (send:%d, receive: %d)\n", + currentNIC + 1, mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64, tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64); + } + break; + } + + case NetworkAttachmentType_Bridged: + { + Bstr strBridgeAdp; + nic->COMGETTER(BridgedInterface)(strBridgeAdp.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("bridgeadapter%d=\"%ls\"\n", currentNIC + 1, strBridgeAdp.raw()); + strAttachment = "bridged"; + } + else + strAttachment = Utf8StrFmt("Bridged Interface '%ls'", strBridgeAdp.raw()); + break; + } + + case NetworkAttachmentType_Internal: + { + Bstr strNetwork; + nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("intnet%d=\"%ls\"\n", currentNIC + 1, strNetwork.raw()); + strAttachment = "intnet"; + } + else + strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).c_str()); + break; + } + + case NetworkAttachmentType_HostOnly: + { + Bstr strHostonlyAdp; + nic->COMGETTER(HostOnlyInterface)(strHostonlyAdp.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("hostonlyadapter%d=\"%ls\"\n", currentNIC + 1, strHostonlyAdp.raw()); + strAttachment = "hostonly"; + } + else + strAttachment = Utf8StrFmt("Host-only Interface '%ls'", strHostonlyAdp.raw()); + break; + } + + case NetworkAttachmentType_Generic: + { + Bstr strGenericDriver; + nic->COMGETTER(GenericDriver)(strGenericDriver.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("generic%d=\"%ls\"\n", currentNIC + 1, strGenericDriver.raw()); + strAttachment = "Generic"; + } + else + { + strAttachment = Utf8StrFmt("Generic '%ls'", strGenericDriver.raw()); + + // show the generic properties + com::SafeArray<BSTR> aProperties; + com::SafeArray<BSTR> aValues; + rc = nic->GetProperties(NULL, + ComSafeArrayAsOutParam(aProperties), + ComSafeArrayAsOutParam(aValues)); + if (SUCCEEDED(rc)) + { + strAttachment += " { "; + for (unsigned i = 0; i < aProperties.size(); ++i) + strAttachment += Utf8StrFmt(!i ? "%ls='%ls'" : ", %ls='%ls'", + aProperties[i], aValues[i]); + strAttachment += " }"; + } + } + break; + } + + case NetworkAttachmentType_NATNetwork: + { + Bstr strNetwork; + nic->COMGETTER(NATNetwork)(strNetwork.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("nat-network%d=\"%ls\"\n", currentNIC + 1, strNetwork.raw()); + strAttachment = "natnetwork"; + } + else + strAttachment = Utf8StrFmt("NAT Network '%s'", Utf8Str(strNetwork).c_str()); + break; + } + + default: + strAttachment = "unknown"; + break; + } + + /* cable connected */ + BOOL fConnected; + nic->COMGETTER(CableConnected)(&fConnected); + + /* promisc policy */ + NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy; + CHECK_ERROR2I_RET(nic, COMGETTER(PromiscModePolicy)(&enmPromiscModePolicy), hrcCheck); + const char *pszPromiscuousGuestPolicy; + switch (enmPromiscModePolicy) + { + case NetworkAdapterPromiscModePolicy_Deny: pszPromiscuousGuestPolicy = "deny"; break; + case NetworkAdapterPromiscModePolicy_AllowNetwork: pszPromiscuousGuestPolicy = "allow-vms"; break; + case NetworkAdapterPromiscModePolicy_AllowAll: pszPromiscuousGuestPolicy = "allow-all"; break; + default: AssertFailedReturn(E_INVALIDARG); + } + + /* trace stuff */ + BOOL fTraceEnabled; + nic->COMGETTER(TraceEnabled)(&fTraceEnabled); + Bstr traceFile; + nic->COMGETTER(TraceFile)(traceFile.asOutParam()); + + /* NIC type */ + NetworkAdapterType_T NICType; + nic->COMGETTER(AdapterType)(&NICType); + const char *pszNICType; + switch (NICType) + { + case NetworkAdapterType_Am79C970A: pszNICType = "Am79C970A"; break; + case NetworkAdapterType_Am79C973: pszNICType = "Am79C973"; break; +#ifdef VBOX_WITH_E1000 + case NetworkAdapterType_I82540EM: pszNICType = "82540EM"; break; + case NetworkAdapterType_I82543GC: pszNICType = "82543GC"; break; + case NetworkAdapterType_I82545EM: pszNICType = "82545EM"; break; +#endif +#ifdef VBOX_WITH_VIRTIO + case NetworkAdapterType_Virtio: pszNICType = "virtio"; break; +#endif + default: AssertFailed(); pszNICType = "unknown"; break; + } + + /* reported line speed */ + ULONG ulLineSpeed; + nic->COMGETTER(LineSpeed)(&ulLineSpeed); + + /* boot priority of the adapter */ + ULONG ulBootPriority; + nic->COMGETTER(BootPriority)(&ulBootPriority); + + /* bandwidth group */ + ComObjPtr<IBandwidthGroup> pBwGroup; + Bstr strBwGroup; + nic->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam()); + if (!pBwGroup.isNull()) + pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam()); + + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("macaddress%d=\"%ls\"\n", currentNIC + 1, strMACAddress.raw()); + RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off"); + RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.c_str()); + RTPrintf("nictype%d=\"%s\"\n", currentNIC + 1, pszNICType); + RTPrintf("nicspeed%d=\"%d\"\n", currentNIC + 1, ulLineSpeed); + } + else + RTPrintf("%-28s MAC: %ls, Attachment: %s, Cable connected: %s, Trace: %s (file: %ls), Type: %s, Reported speed: %d Mbps, Boot priority: %d, Promisc Policy: %s, Bandwidth group: %ls\n", + szNm, strMACAddress.raw(), strAttachment.c_str(), + fConnected ? "on" : "off", + fTraceEnabled ? "on" : "off", + traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(), + pszNICType, + ulLineSpeed / 1000, + (int)ulBootPriority, + pszPromiscuousGuestPolicy, + strBwGroup.isEmpty() ? Bstr("none").raw() : strBwGroup.raw()); + if (strNatSettings.length()) + RTPrintf(strNatSettings.c_str()); + if (strNatForwardings.length()) + RTPrintf(strNatForwardings.c_str()); + } + } + } + + /* Pointing device information */ + PointingHIDType_T aPointingHID; + const char *pszHID = "Unknown"; + const char *pszMrHID = "unknown"; + machine->COMGETTER(PointingHIDType)(&aPointingHID); + switch (aPointingHID) + { + case PointingHIDType_None: + pszHID = "None"; + pszMrHID = "none"; + break; + case PointingHIDType_PS2Mouse: + pszHID = "PS/2 Mouse"; + pszMrHID = "ps2mouse"; + break; + case PointingHIDType_USBMouse: + pszHID = "USB Mouse"; + pszMrHID = "usbmouse"; + break; + case PointingHIDType_USBTablet: + pszHID = "USB Tablet"; + pszMrHID = "usbtablet"; + break; + case PointingHIDType_ComboMouse: + pszHID = "USB Tablet and PS/2 Mouse"; + pszMrHID = "combomouse"; + break; + case PointingHIDType_USBMultiTouch: + pszHID = "USB Multi-Touch"; + pszMrHID = "usbmultitouch"; + break; + default: + break; + } + SHOW_UTF8_STRING("hidpointing", "Pointing Device:", details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID); + + /* Keyboard device information */ + KeyboardHIDType_T aKeyboardHID; + machine->COMGETTER(KeyboardHIDType)(&aKeyboardHID); + pszHID = "Unknown"; + pszMrHID = "unknown"; + switch (aKeyboardHID) + { + case KeyboardHIDType_None: + pszHID = "None"; + pszMrHID = "none"; + break; + case KeyboardHIDType_PS2Keyboard: + pszHID = "PS/2 Keyboard"; + pszMrHID = "ps2kbd"; + break; + case KeyboardHIDType_USBKeyboard: + pszHID = "USB Keyboard"; + pszMrHID = "usbkbd"; + break; + case KeyboardHIDType_ComboKeyboard: + pszHID = "USB and PS/2 Keyboard"; + pszMrHID = "combokbd"; + break; + default: + break; + } + SHOW_UTF8_STRING("hidkeyboard", "Keyboard Device:", details == VMINFO_MACHINEREADABLE ? pszMrHID : pszHID); + + ComPtr<ISystemProperties> sysProps; + pVirtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam()); + + /* get the maximum amount of UARTs */ + ULONG maxUARTs = 0; + sysProps->COMGETTER(SerialPortCount)(&maxUARTs); + for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++) + { + ComPtr<ISerialPort> uart; + rc = machine->GetSerialPort(currentUART, uart.asOutParam()); + if (SUCCEEDED(rc) && uart) + { + FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "uart%u" : "UART %u:", currentUART + 1); + + /* show the config of this UART */ + BOOL fEnabled; + uart->COMGETTER(Enabled)(&fEnabled); + if (!fEnabled) + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("%s=\"off\"\n", szNm); + else + RTPrintf("%-28s disabled\n", szNm); + } + else + { + ULONG ulIRQ, ulIOBase; + PortMode_T HostMode; + Bstr path; + BOOL fServer; + UartType_T UartType; + uart->COMGETTER(IRQ)(&ulIRQ); + uart->COMGETTER(IOBase)(&ulIOBase); + uart->COMGETTER(Path)(path.asOutParam()); + uart->COMGETTER(Server)(&fServer); + uart->COMGETTER(HostMode)(&HostMode); + uart->COMGETTER(UartType)(&UartType); + + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOBase, ulIRQ); + else + RTPrintf("%-28s I/O base: %#06x, IRQ: %d", szNm, ulIOBase, ulIRQ); + switch (HostMode) + { + default: + case PortMode_Disconnected: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1); + else + RTPrintf(", disconnected"); + break; + case PortMode_RawFile: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uartmode%d=\"file,%ls\"\n", currentUART + 1, + path.raw()); + else + RTPrintf(", attached to raw file '%ls'\n", + path.raw()); + break; + case PortMode_TCP: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uartmode%d=\"%s,%ls\"\n", currentUART + 1, + fServer ? "tcpserver" : "tcpclient", path.raw()); + else + RTPrintf(", attached to tcp (%s) '%ls'", + fServer ? "server" : "client", path.raw()); + break; + case PortMode_HostPipe: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uartmode%d=\"%s,%ls\"\n", currentUART + 1, + fServer ? "server" : "client", path.raw()); + else + RTPrintf(", attached to pipe (%s) '%ls'", + fServer ? "server" : "client", path.raw()); + break; + case PortMode_HostDevice: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uartmode%d=\"%ls\"\n", currentUART + 1, + path.raw()); + else + RTPrintf(", attached to device '%ls'", path.raw()); + break; + } + switch (UartType) + { + default: + case UartType_U16450: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uarttype%d=\"16450\"\n", currentUART + 1); + else + RTPrintf(", 16450\n"); + break; + case UartType_U16550A: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uarttype%d=\"16550A\"\n", currentUART + 1); + else + RTPrintf(", 16550A\n"); + break; + case UartType_U16750: + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("uarttype%d=\"16750\"\n", currentUART + 1); + else + RTPrintf(", 16750\n"); + break; + } + } + } + } + + /* get the maximum amount of LPTs */ + ULONG maxLPTs = 0; + sysProps->COMGETTER(ParallelPortCount)(&maxLPTs); + for (ULONG currentLPT = 0; currentLPT < maxLPTs; currentLPT++) + { + ComPtr<IParallelPort> lpt; + rc = machine->GetParallelPort(currentLPT, lpt.asOutParam()); + if (SUCCEEDED(rc) && lpt) + { + FmtNm(szNm, details == VMINFO_MACHINEREADABLE ? "lpt%u" : "LPT %u:", currentLPT + 1); + + /* show the config of this LPT */ + BOOL fEnabled; + lpt->COMGETTER(Enabled)(&fEnabled); + if (!fEnabled) + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("%s=\"off\"\n", szNm); + else + RTPrintf("%-28s disabled\n", szNm); + } + else + { + ULONG ulIRQ, ulIOBase; + Bstr path; + lpt->COMGETTER(IRQ)(&ulIRQ); + lpt->COMGETTER(IOBase)(&ulIOBase); + lpt->COMGETTER(Path)(path.asOutParam()); + + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("%s=\"%#06x,%d\"\n", szNm, ulIOBase, ulIRQ); + else + RTPrintf("%-28s I/O base: %#06x, IRQ: %d", szNm, ulIOBase, ulIRQ); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("lptmode%d=\"%ls\"\n", currentLPT + 1, path.raw()); + else + RTPrintf(", attached to device '%ls'\n", path.raw()); + } + } + } + + ComPtr<IAudioAdapter> AudioAdapter; + rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam()); + if (SUCCEEDED(rc)) + { + const char *pszDrv = "Unknown"; + const char *pszCtrl = "Unknown"; + const char *pszCodec = "Unknown"; + BOOL fEnabled; + rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled); + if (SUCCEEDED(rc) && fEnabled) + { + AudioDriverType_T enmDrvType; + rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType); + switch (enmDrvType) + { + case AudioDriverType_Null: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "null"; + else + pszDrv = "Null"; + break; + case AudioDriverType_WinMM: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "winmm"; + else + pszDrv = "WINMM"; + break; + case AudioDriverType_DirectSound: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "dsound"; + else + pszDrv = "DSOUND"; + break; + case AudioDriverType_OSS: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "oss"; + else + pszDrv = "OSS"; + break; + case AudioDriverType_ALSA: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "alsa"; + else + pszDrv = "ALSA"; + break; + case AudioDriverType_Pulse: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "pulse"; + else + pszDrv = "PulseAudio"; + break; + case AudioDriverType_CoreAudio: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "coreaudio"; + else + pszDrv = "CoreAudio"; + break; + case AudioDriverType_SolAudio: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "solaudio"; + else + pszDrv = "SolAudio"; + break; + default: + if (details == VMINFO_MACHINEREADABLE) + pszDrv = "unknown"; + break; + } + AudioControllerType_T enmCtrlType; + rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType); + switch (enmCtrlType) + { + case AudioControllerType_AC97: + if (details == VMINFO_MACHINEREADABLE) + pszCtrl = "ac97"; + else + pszCtrl = "AC97"; + break; + case AudioControllerType_SB16: + if (details == VMINFO_MACHINEREADABLE) + pszCtrl = "sb16"; + else + pszCtrl = "SB16"; + break; + case AudioControllerType_HDA: + if (details == VMINFO_MACHINEREADABLE) + pszCtrl = "hda"; + else + pszCtrl = "HDA"; + break; + default: + break; + } + AudioCodecType_T enmCodecType; + rc = AudioAdapter->COMGETTER(AudioCodec)(&enmCodecType); + switch (enmCodecType) + { + case AudioCodecType_SB16: + pszCodec = "SB16"; + break; + case AudioCodecType_STAC9700: + pszCodec = "STAC9700"; + break; + case AudioCodecType_AD1980: + pszCodec = "AD1980"; + break; + case AudioCodecType_STAC9221: + pszCodec = "STAC9221"; + break; + case AudioCodecType_Null: break; /* Shut up MSC. */ + default: break; + } + } + else + fEnabled = FALSE; + + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("audio=\"%s\"\n", fEnabled ? pszDrv : "none"); + else + { + RTPrintf("%-28s %s", "Audio:", fEnabled ? "enabled" : "disabled"); + if (fEnabled) + RTPrintf(" (Driver: %s, Controller: %s, Codec: %s)", pszDrv, pszCtrl, pszCodec); + RTPrintf("\n"); + } + SHOW_BOOLEAN_PROP(AudioAdapter, EnabledIn, "audio_in", "Audio playback:"); + SHOW_BOOLEAN_PROP(AudioAdapter, EnabledOut, "audio_out", "Audio capture:"); + } + + /* Shared clipboard */ + { + const char *psz; + ClipboardMode_T enmMode = (ClipboardMode_T)0; + rc = machine->COMGETTER(ClipboardMode)(&enmMode); + switch (enmMode) + { + case ClipboardMode_Disabled: + psz = "disabled"; + break; + case ClipboardMode_HostToGuest: + psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : "HostToGuest"; + break; + case ClipboardMode_GuestToHost: + psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : "GuestToHost"; + break; + case ClipboardMode_Bidirectional: + psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : "Bidirectional"; + break; + default: + psz = details == VMINFO_MACHINEREADABLE ? "unknown" : "Unknown"; + break; + } + SHOW_UTF8_STRING("clipboard", "Clipboard Mode:", psz); + } + + /* Drag and drop */ + { + const char *psz; + DnDMode_T enmMode; + rc = machine->COMGETTER(DnDMode)(&enmMode); + switch (enmMode) + { + case DnDMode_Disabled: + psz = "disabled"; + break; + case DnDMode_HostToGuest: + psz = details == VMINFO_MACHINEREADABLE ? "hosttoguest" : "HostToGuest"; + break; + case DnDMode_GuestToHost: + psz = details == VMINFO_MACHINEREADABLE ? "guesttohost" : "GuestToHost"; + break; + case DnDMode_Bidirectional: + psz = details == VMINFO_MACHINEREADABLE ? "bidirectional" : "Bidirectional"; + break; + default: + psz = details == VMINFO_MACHINEREADABLE ? "unknown" : "Unknown"; + break; + } + SHOW_UTF8_STRING("draganddrop", "Drag and drop Mode:", psz); + } + + { + SessionState_T sessState; + rc = machine->COMGETTER(SessionState)(&sessState); + if (SUCCEEDED(rc) && sessState != SessionState_Unlocked) + { + Bstr sessName; + rc = machine->COMGETTER(SessionName)(sessName.asOutParam()); + if (SUCCEEDED(rc) && !sessName.isEmpty()) + SHOW_BSTR_STRING("SessionName", "Session name:", sessName); + } + } + + if (pConsole) + { + do + { + ComPtr<IDisplay> display; + rc = pConsole->COMGETTER(Display)(display.asOutParam()); + if (rc == E_ACCESSDENIED || display.isNull()) + break; /* VM not powered up */ + if (FAILED(rc)) + { + com::GlueHandleComError(pConsole, "COMGETTER(Display)(display.asOutParam())", rc, __FILE__, __LINE__); + return rc; + } + ULONG xRes, yRes, bpp; + LONG xOrigin, yOrigin; + GuestMonitorStatus_T monitorStatus; + rc = display->GetScreenResolution(0, &xRes, &yRes, &bpp, &xOrigin, &yOrigin, &monitorStatus); + if (rc == E_ACCESSDENIED) + break; /* VM not powered up */ + if (FAILED(rc)) + { + com::ErrorInfo info(display, COM_IIDOF(IDisplay)); + GluePrintErrorInfo(info); + return rc; + } + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("VideoMode=\"%d,%d,%d\"@%d,%d %d\n", xRes, yRes, bpp, xOrigin, yOrigin, monitorStatus); + else + { + const char *pszMonitorStatus = "unknown status"; + switch (monitorStatus) + { + case GuestMonitorStatus_Blank: pszMonitorStatus = "blank"; break; + case GuestMonitorStatus_Enabled: pszMonitorStatus = "enabled"; break; + case GuestMonitorStatus_Disabled: pszMonitorStatus = "disabled"; break; + default: break; + } + RTPrintf("%-28s %dx%dx%d at %d,%d %s\n", "Video mode:", xRes, yRes, bpp, xOrigin, yOrigin, pszMonitorStatus); + } + } + while (0); + } + + /* + * Remote Desktop + */ + ComPtr<IVRDEServer> vrdeServer; + rc = machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + if (SUCCEEDED(rc) && vrdeServer) + { + BOOL fEnabled = false; + vrdeServer->COMGETTER(Enabled)(&fEnabled); + if (fEnabled) + { + LONG currentPort = -1; + Bstr ports; + vrdeServer->GetVRDEProperty(Bstr("TCP/Ports").raw(), ports.asOutParam()); + Bstr address; + vrdeServer->GetVRDEProperty(Bstr("TCP/Address").raw(), address.asOutParam()); + BOOL fMultiCon; + vrdeServer->COMGETTER(AllowMultiConnection)(&fMultiCon); + BOOL fReuseCon; + vrdeServer->COMGETTER(ReuseSingleConnection)(&fReuseCon); + Bstr videoChannel; + vrdeServer->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(), videoChannel.asOutParam()); + BOOL fVideoChannel = (videoChannel.compare(Bstr("true"), Bstr::CaseInsensitive)== 0) + || (videoChannel == "1"); + Bstr videoChannelQuality; + vrdeServer->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(), videoChannelQuality.asOutParam()); + AuthType_T authType = (AuthType_T)0; + const char *strAuthType; + vrdeServer->COMGETTER(AuthType)(&authType); + switch (authType) + { + case AuthType_Null: + strAuthType = "null"; + break; + case AuthType_External: + strAuthType = "external"; + break; + case AuthType_Guest: + strAuthType = "guest"; + break; + default: + strAuthType = "unknown"; + break; + } + if (pConsole) + { + ComPtr<IVRDEServerInfo> vrdeServerInfo; + CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc); + if (!vrdeServerInfo.isNull()) + { + rc = vrdeServerInfo->COMGETTER(Port)(¤tPort); + if (rc == E_ACCESSDENIED) + { + currentPort = -1; /* VM not powered up */ + } + else if (FAILED(rc)) + { + com::ErrorInfo info(vrdeServerInfo, COM_IIDOF(IVRDEServerInfo)); + GluePrintErrorInfo(info); + return rc; + } + } + } + if (details == VMINFO_MACHINEREADABLE) + { + RTPrintf("vrde=\"on\"\n"); + RTPrintf("vrdeport=%d\n", currentPort); + RTPrintf("vrdeports=\"%ls\"\n", ports.raw()); + RTPrintf("vrdeaddress=\"%ls\"\n", address.raw()); + RTPrintf("vrdeauthtype=\"%s\"\n", strAuthType); + RTPrintf("vrdemulticon=\"%s\"\n", fMultiCon ? "on" : "off"); + RTPrintf("vrdereusecon=\"%s\"\n", fReuseCon ? "on" : "off"); + RTPrintf("vrdevideochannel=\"%s\"\n", fVideoChannel ? "on" : "off"); + if (fVideoChannel) + RTPrintf("vrdevideochannelquality=\"%ls\"\n", videoChannelQuality.raw()); + } + else + { + if (address.isEmpty()) + address = "0.0.0.0"; + RTPrintf("%-28s enabled (Address %ls, Ports %ls, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n", + "VRDE:", address.raw(), ports.raw(), fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType); + if (pConsole && currentPort != -1 && currentPort != 0) + RTPrintf("%-28s %d\n", "VRDE port:", currentPort); + if (fVideoChannel) + RTPrintf("%-28s enabled (Quality %ls)\n", "Video redirection:", videoChannelQuality.raw()); + else + RTPrintf("%-28s disabled\n", "Video redirection:"); + } + com::SafeArray<BSTR> aProperties; + if (SUCCEEDED(vrdeServer->COMGETTER(VRDEProperties)(ComSafeArrayAsOutParam(aProperties)))) + { + unsigned i; + for (i = 0; i < aProperties.size(); ++i) + { + Bstr value; + vrdeServer->GetVRDEProperty(aProperties[i], value.asOutParam()); + if (details == VMINFO_MACHINEREADABLE) + { + if (value.isEmpty()) + RTPrintf("vrdeproperty[%ls]=<not set>\n", aProperties[i]); + else + RTPrintf("vrdeproperty[%ls]=\"%ls\"\n", aProperties[i], value.raw()); + } + else + { + if (value.isEmpty()) + RTPrintf("%-28s: %-10lS = <not set>\n", "VRDE property", aProperties[i]); + else + RTPrintf("%-28s: %-10lS = \"%ls\"\n", "VRDE property", aProperties[i], value.raw()); + } + } + } + } + else + { + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("vrde=\"off\"\n"); + else + RTPrintf("%-28s disabled\n", "VRDE:"); + } + } + + /* + * USB. + */ + SafeIfaceArray<IUSBController> USBCtlColl; + rc = machine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(USBCtlColl)); + if (SUCCEEDED(rc)) + { + bool fOhciEnabled = false; + bool fEhciEnabled = false; + bool fXhciEnabled = false; + + for (unsigned i = 0; i < USBCtlColl.size(); i++) + { + USBControllerType_T enmType; + + rc = USBCtlColl[i]->COMGETTER(Type)(&enmType); + if (SUCCEEDED(rc)) + { + switch (enmType) + { + case USBControllerType_OHCI: + fOhciEnabled = true; + break; + case USBControllerType_EHCI: + fEhciEnabled = true; + break; + case USBControllerType_XHCI: + fXhciEnabled = true; + break; + default: + break; + } + } + } + + SHOW_BOOL_VALUE("usb", "OHCI USB:", fOhciEnabled); + SHOW_BOOL_VALUE("ehci", "EHCI USB:", fEhciEnabled); + SHOW_BOOL_VALUE("xhci", "xHCI USB:", fXhciEnabled); + } + + ComPtr<IUSBDeviceFilters> USBFlts; + rc = machine->COMGETTER(USBDeviceFilters)(USBFlts.asOutParam()); + if (SUCCEEDED(rc)) + { + SafeIfaceArray <IUSBDeviceFilter> Coll; + rc = USBFlts->COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll)); + if (SUCCEEDED(rc)) + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\nUSB Device Filters:\n\n"); + + if (Coll.size() == 0) + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("<none>\n\n"); + } + else + { + for (size_t index = 0; index < Coll.size(); ++index) + { + ComPtr<IUSBDeviceFilter> DevPtr = Coll[index]; + + if (details != VMINFO_MACHINEREADABLE) + SHOW_UTF8_STRING("index", "Index:", FmtNm(szNm, "%zu", index)); + SHOW_BOOLEAN_PROP_EX(DevPtr, Active, FmtNm(szNm, "USBFilterActive%zu", index + 1), "Active:", "yes", "no"); + SHOW_STRING_PROP(DevPtr, Name, FmtNm(szNm, "USBFilterName%zu", index + 1), "Name:"); + SHOW_STRING_PROP(DevPtr, VendorId, FmtNm(szNm, "USBFilterVendorId%zu", index + 1), "VendorId:"); + SHOW_STRING_PROP(DevPtr, ProductId, FmtNm(szNm, "USBFilterProductId%zu", index + 1), "ProductId:"); + SHOW_STRING_PROP(DevPtr, Revision, FmtNm(szNm, "USBFilterRevision%zu", index + 1), "Revision:"); + SHOW_STRING_PROP(DevPtr, Manufacturer, FmtNm(szNm, "USBFilterManufacturer%zu", index + 1), "Manufacturer:"); + SHOW_STRING_PROP(DevPtr, Product, FmtNm(szNm, "USBFilterProduct%zu", index + 1), "Product:"); + SHOW_STRING_PROP(DevPtr, Remote, FmtNm(szNm, "USBFilterRemote%zu", index + 1), "Remote:"); + SHOW_STRING_PROP(DevPtr, SerialNumber, FmtNm(szNm, "USBFilterSerialNumber%zu", index + 1), "Serial Number:"); + if (details != VMINFO_MACHINEREADABLE) + { + ULONG fMaskedIfs; + CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), rc); + if (fMaskedIfs) + RTPrintf("%-28s %#010x\n", "Masked Interfaces:", fMaskedIfs); + RTPrintf("\n"); + } + } + } + } + + if (pConsole) + { + /* scope */ + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Available remote USB devices:\n\n"); + + SafeIfaceArray <IHostUSBDevice> coll; + CHECK_ERROR_RET(pConsole, COMGETTER(RemoteUSBDevices)(ComSafeArrayAsOutParam(coll)), rc); + + if (coll.size() == 0) + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("<none>\n\n"); + } + else + { + /* This code is duplicated below, with USBAttach as prefix. */ + const char *pszPfx = "USBRemote"; + for (size_t i = 0; i < coll.size(); ++i) + { + ComPtr<IHostUSBDevice> dev = coll[i]; + + SHOW_STRING_PROP(dev, Id, FmtNm(szNm, "%sActive%zu", pszPfx, i + 1), "UUID:"); + SHOW_USHORT_PROP_EX2(dev, VendorId, FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1), "VendorId:", "", "%#06x", "%#06x (%04X)"); + SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), "ProductId:", "", "%#06x", "%#06x (%04X)"); + + USHORT bcdRevision; + CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc); + if (details == VMINFO_MACHINEREADABLE) + RTStrPrintf(szValue, sizeof(szValue), "%#04x%02x", bcdRevision >> 8, bcdRevision & 0xff); + else + RTStrPrintf(szValue, sizeof(szValue), "%u.%u (%02u%02u)\n", + bcdRevision >> 8, bcdRevision & 0xff, bcdRevision >> 8, bcdRevision & 0xff); + SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), "Revision:", szValue); + + SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), "Manufacturer:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, Product, FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1), "Product:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), "SerialNumber:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, Address, FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1), "Address:"); + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + } + } + } + + /* scope */ + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Currently Attached USB Devices:\n\n"); + + SafeIfaceArray <IUSBDevice> coll; + CHECK_ERROR_RET(pConsole, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)), rc); + + if (coll.size() == 0) + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("<none>\n\n"); + } + else + { + /* This code is duplicated below, with USBAttach as prefix. */ + const char *pszPfx = "USBAttach"; + for (size_t i = 0; i < coll.size(); ++i) + { + ComPtr<IHostUSBDevice> dev = coll[i]; + + SHOW_STRING_PROP(dev, Id, FmtNm(szNm, "%sActive%zu", pszPfx, i + 1), "UUID:"); + SHOW_USHORT_PROP_EX2(dev, VendorId, FmtNm(szNm, "%sVendorId%zu", pszPfx, i + 1), "VendorId:", "", "%#06x", "%#06x (%04X)"); + SHOW_USHORT_PROP_EX2(dev, ProductId, FmtNm(szNm, "%sProductId%zu", pszPfx, i + 1), "ProductId:", "", "%#06x", "%#06x (%04X)"); + + USHORT bcdRevision; + CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc); + if (details == VMINFO_MACHINEREADABLE) + RTStrPrintf(szValue, sizeof(szValue), "%#04x%02x", bcdRevision >> 8, bcdRevision & 0xff); + else + RTStrPrintf(szValue, sizeof(szValue), "%u.%u (%02u%02u)\n", + bcdRevision >> 8, bcdRevision & 0xff, bcdRevision >> 8, bcdRevision & 0xff); + SHOW_UTF8_STRING(FmtNm(szNm, "%sRevision%zu", pszPfx, i + 1), "Revision:", szValue); + + SHOW_STRING_PROP_NOT_EMPTY(dev, Manufacturer, FmtNm(szNm, "%sManufacturer%zu", pszPfx, i + 1), "Manufacturer:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, Product, FmtNm(szNm, "%sProduct%zu", pszPfx, i + 1), "Product:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, SerialNumber, FmtNm(szNm, "%sSerialNumber%zu", pszPfx, i + 1), "SerialNumber:"); + SHOW_STRING_PROP_NOT_EMPTY(dev, Address, FmtNm(szNm, "%sAddress%zu", pszPfx, i + 1), "Address:"); + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + } + } + } + } + } /* USB */ + +#ifdef VBOX_WITH_PCI_PASSTHROUGH + /* Host PCI passthrough devices */ + { + SafeIfaceArray <IPCIDeviceAttachment> assignments; + rc = machine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments)); + if (SUCCEEDED(rc)) + { + if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE)) + { + RTPrintf("\nAttached physical PCI devices:\n\n"); + } + + for (size_t index = 0; index < assignments.size(); ++index) + { + ComPtr<IPCIDeviceAttachment> Assignment = assignments[index]; + char szHostPCIAddress[32], szGuestPCIAddress[32]; + LONG iHostPCIAddress = -1, iGuestPCIAddress = -1; + Bstr DevName; + + Assignment->COMGETTER(Name)(DevName.asOutParam()); + Assignment->COMGETTER(HostAddress)(&iHostPCIAddress); + Assignment->COMGETTER(GuestAddress)(&iGuestPCIAddress); + PCIBusAddress().fromLong(iHostPCIAddress).format(szHostPCIAddress, sizeof(szHostPCIAddress)); + PCIBusAddress().fromLong(iGuestPCIAddress).format(szGuestPCIAddress, sizeof(szGuestPCIAddress)); + + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("AttachedHostPCI=%s,%s\n", szHostPCIAddress, szGuestPCIAddress); + else + RTPrintf(" Host device %ls at %s attached as %s\n", DevName.raw(), szHostPCIAddress, szGuestPCIAddress); + } + + if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE)) + { + RTPrintf("\n"); + } + } + } + /* Host PCI passthrough devices */ +#endif + + /* + * Bandwidth groups + */ + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Bandwidth groups: "); + { + ComPtr<IBandwidthControl> bwCtrl; + CHECK_ERROR_RET(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()), rc); + + rc = showBandwidthGroups(bwCtrl, details); + } + + + /* + * Shared folders + */ + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Shared folders:"); + uint32_t numSharedFolders = 0; +#if 0 // not yet implemented + /* globally shared folders first */ + { + SafeIfaceArray <ISharedFolder> sfColl; + CHECK_ERROR_RET(pVirtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc); + for (size_t i = 0; i < sfColl.size(); ++i) + { + ComPtr<ISharedFolder> sf = sfColl[i]; + showSharedFolder(sf, details, "global mapping", "GlobalMapping", i + 1, numSharedFolders == 0); + ++numSharedFolders; + } + } +#endif + /* now VM mappings */ + { + com::SafeIfaceArray <ISharedFolder> folders; + CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc); + for (size_t i = 0; i < folders.size(); ++i) + { + ComPtr<ISharedFolder> sf = folders[i]; + showSharedFolder(sf, details, "machine mapping", "MachineMapping", i + 1, numSharedFolders == 0); + ++numSharedFolders; + } + } + /* transient mappings */ + if (pConsole) + { + com::SafeIfaceArray <ISharedFolder> folders; + CHECK_ERROR_RET(pConsole, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc); + for (size_t i = 0; i < folders.size(); ++i) + { + ComPtr<ISharedFolder> sf = folders[i]; + showSharedFolder(sf, details, "transient mapping", "TransientMapping", i + 1, numSharedFolders == 0); + ++numSharedFolders; + } + } + if (!numSharedFolders && details != VMINFO_MACHINEREADABLE) + RTPrintf("<none>\n"); + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + + if (pConsole) + { + /* + * Live VRDE info. + */ + ComPtr<IVRDEServerInfo> vrdeServerInfo; + CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc); + BOOL fActive = FALSE; + ULONG cNumberOfClients = 0; + LONG64 BeginTime = 0; + LONG64 EndTime = 0; + LONG64 BytesSent = 0; + LONG64 BytesSentTotal = 0; + LONG64 BytesReceived = 0; + LONG64 BytesReceivedTotal = 0; + Bstr User; + Bstr Domain; + Bstr ClientName; + Bstr ClientIP; + ULONG ClientVersion = 0; + ULONG EncryptionStyle = 0; + + if (!vrdeServerInfo.isNull()) + { + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Active)(&fActive), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(NumberOfClients)(&cNumberOfClients), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BeginTime)(&BeginTime), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EndTime)(&EndTime), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSent)(&BytesSent), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSentTotal)(&BytesSentTotal), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceived)(&BytesReceived), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceivedTotal)(&BytesReceivedTotal), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(User)(User.asOutParam()), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Domain)(Domain.asOutParam()), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientName)(ClientName.asOutParam()), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientIP)(ClientIP.asOutParam()), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientVersion)(&ClientVersion), rc); + CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EncryptionStyle)(&EncryptionStyle), rc); + } + + SHOW_BOOL_VALUE_EX("VRDEActiveConnection", "VRDE Connection:", fActive, "active", "not active"); + SHOW_ULONG_VALUE("VRDEClients=", "Clients so far:", cNumberOfClients, ""); + + if (cNumberOfClients > 0) + { + char szTimeValue[128]; + makeTimeStr(szTimeValue, sizeof(szTimeValue), BeginTime); + if (fActive) + SHOW_UTF8_STRING("VRDEStartTime", "Start time:", szTimeValue); + else + { + SHOW_UTF8_STRING("VRDELastStartTime", "Last started:", szTimeValue); + makeTimeStr(szTimeValue, sizeof(szTimeValue), EndTime); + SHOW_UTF8_STRING("VRDELastEndTime", "Last ended:", szTimeValue); + } + + int64_t ThroughputSend = 0; + int64_t ThroughputReceive = 0; + if (EndTime != BeginTime) + { + ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime); + ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime); + } + SHOW_LONG64_VALUE("VRDEBytesSent", "Sent:", BytesSent, "Bytes"); + SHOW_LONG64_VALUE("VRDEThroughputSend", "Average speed:", ThroughputSend, "B/s"); + SHOW_LONG64_VALUE("VRDEBytesSentTotal", "Sent total:", BytesSentTotal, "Bytes"); + + SHOW_LONG64_VALUE("VRDEBytesReceived", "Received:", BytesReceived, "Bytes"); + SHOW_LONG64_VALUE("VRDEThroughputReceive", "Speed:", ThroughputReceive, "B/s"); + SHOW_LONG64_VALUE("VRDEBytesReceivedTotal", "Received total:", BytesReceivedTotal, "Bytes"); + + if (fActive) + { + SHOW_BSTR_STRING("VRDEUserName", "User name:", User); + SHOW_BSTR_STRING("VRDEDomain", "Domain:", Domain); + SHOW_BSTR_STRING("VRDEClientName", "Client name:", ClientName); + SHOW_BSTR_STRING("VRDEClientIP", "Client IP:", ClientIP); + SHOW_ULONG_VALUE("VRDEClientVersion", "Client version:", ClientVersion, ""); + SHOW_UTF8_STRING("VRDEEncryption", "Encryption:", EncryptionStyle == 0 ? "RDP4" : "RDP5 (X.509)"); + } + } + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + } + +#ifdef VBOX_WITH_RECORDING + { + /* Video capture */ + BOOL fCaptureVideo = FALSE; +# ifdef VBOX_WITH_AUDIO_RECORDING + BOOL fCaptureAudio = FALSE; +# endif + + ComPtr<IRecordingSettings> recordingSettings; + CHECK_ERROR_RET(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()), rc); + + SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens; + CHECK_ERROR_RET(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)), rc); + + /* For now all screens have the same configuration; so take screen 0 and work with that. */ + ULONG fFeatures; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Features)(&fFeatures), rc); + ULONG Width; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoWidth)(&Width), rc); + ULONG Height; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoHeight)(&Height), rc); + ULONG Rate; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoRate)(&Rate), rc); + ULONG Fps; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(VideoFPS)(&Fps), rc); + Bstr bstrFile; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Filename)(bstrFile.asOutParam()), rc); + Bstr bstrOptions; + CHECK_ERROR_RET(saRecordingScreenScreens[0], COMGETTER(Options)(bstrOptions.asOutParam()), rc); + + Utf8Str strOptions(bstrOptions); + size_t pos = 0; + com::Utf8Str key, value; + while ((pos = strOptions.parseKeyValue(key, value, pos)) != com::Utf8Str::npos) + { + if (key.compare("vc_enabled", Utf8Str::CaseInsensitive) == 0) + { + fCaptureVideo = value.compare("true", Utf8Str::CaseInsensitive) == 0; + } + else if (key.compare("ac_enabled", Utf8Str::CaseInsensitive) == 0) + { +# ifdef VBOX_WITH_AUDIO_RECORDING + fCaptureAudio = value.compare("true", Utf8Str::CaseInsensitive) == 0; +# endif + } + } + + SHOW_BOOL_VALUE_EX("videocap", "Capturing:", fCaptureVideo, "active", "not active"); +# ifdef VBOX_WITH_AUDIO_RECORDING + SHOW_BOOL_VALUE_EX("videocapaudio", "Capture audio:", fCaptureAudio, "active", "not active"); +# endif + szValue[0] = '\0'; + for (size_t i = 0, off = 0; i < saRecordingScreenScreens.size(); i++) + { + BOOL fEnabled; + CHECK_ERROR_RET(saRecordingScreenScreens[i], COMGETTER(Enabled)(&fEnabled), rc); + if (fEnabled && off < sizeof(szValue) - 3) + off += RTStrPrintf(&szValue[off], sizeof(szValue) - off, off ? ",%zu" : "%zu", i); + } + SHOW_UTF8_STRING("capturescreens", "Capture screens:", szValue); + SHOW_BSTR_STRING("capturefilename", "Capture file:", bstrFile); + RTStrPrintf(szValue, sizeof(szValue), "%ux%u", Width, Height); + SHOW_UTF8_STRING("captureres", "Capture dimensions:", szValue); + SHOW_ULONG_VALUE("capturevideorate", "Capture rate:", Rate, "kbps"); + SHOW_ULONG_VALUE("capturevideofps", "Capture FPS:", Fps, "kbps"); + SHOW_BSTR_STRING("captureopts", "Capture options:", bstrOptions); + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + /** @todo Add more audio capturing profile / information here. */ + } +#endif /* VBOX_WITH_RECORDING */ + + if ( details == VMINFO_STANDARD + || details == VMINFO_FULL + || details == VMINFO_MACHINEREADABLE) + { + Bstr description; + machine->COMGETTER(Description)(description.asOutParam()); + if (!description.isEmpty()) + { + if (details == VMINFO_MACHINEREADABLE) + outputMachineReadableString("description", &description); + else + RTPrintf("Description:\n%ls\n", description.raw()); + } + } + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Guest:\n\n"); + + SHOW_ULONG_PROP(machine, MemoryBalloonSize, "GuestMemoryBalloon", "Configured memory balloon size:", "MB"); + + if (pConsole) + { + ComPtr<IGuest> guest; + rc = pConsole->COMGETTER(Guest)(guest.asOutParam()); + if (SUCCEEDED(rc) && !guest.isNull()) + { + SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", "OS type:"); + + AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */ + rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel); + if (SUCCEEDED(rc)) + SHOW_ULONG_VALUE("GuestAdditionsRunLevel", "Additions run level:", (ULONG)guestRunLevel, ""); + + Bstr guestString; + rc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam()); + if ( SUCCEEDED(rc) + && !guestString.isEmpty()) + { + ULONG uRevision; + rc = guest->COMGETTER(AdditionsRevision)(&uRevision); + if (FAILED(rc)) + uRevision = 0; + RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision); + SHOW_UTF8_STRING("GuestAdditionsVersion", "Additions version", szValue); + } + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\nGuest Facilities:\n\n"); + + /* Print information about known Guest Additions facilities: */ + SafeIfaceArray <IAdditionsFacility> collFac; + CHECK_ERROR_RET(guest, COMGETTER(Facilities)(ComSafeArrayAsOutParam(collFac)), rc); + LONG64 lLastUpdatedMS; + char szLastUpdated[32]; + AdditionsFacilityStatus_T curStatus; + for (size_t index = 0; index < collFac.size(); ++index) + { + ComPtr<IAdditionsFacility> fac = collFac[index]; + if (fac) + { + CHECK_ERROR_RET(fac, COMGETTER(Name)(guestString.asOutParam()), rc); + if (!guestString.isEmpty()) + { + CHECK_ERROR_RET(fac, COMGETTER(Status)(&curStatus), rc); + CHECK_ERROR_RET(fac, COMGETTER(LastUpdated)(&lLastUpdatedMS), rc); + if (details == VMINFO_MACHINEREADABLE) + RTPrintf("GuestAdditionsFacility_%ls=%u,%lld\n", + guestString.raw(), curStatus, lLastUpdatedMS); + else + { + makeTimeStr(szLastUpdated, sizeof(szLastUpdated), lLastUpdatedMS); + RTPrintf("Facility \"%ls\": %s (last update: %s)\n", + guestString.raw(), facilityStateToName(curStatus, false /* No short naming */), szLastUpdated); + } + } + else + AssertMsgFailed(("Facility with undefined name retrieved!\n")); + } + else + AssertMsgFailed(("Invalid facility returned!\n")); + } + if (!collFac.size() && details != VMINFO_MACHINEREADABLE) + RTPrintf("No active facilities.\n"); + } + } + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + + /* + * snapshots + */ + ComPtr<ISnapshot> snapshot; + rc = machine->FindSnapshot(Bstr().raw(), snapshot.asOutParam()); + if (SUCCEEDED(rc) && snapshot) + { + ComPtr<ISnapshot> currentSnapshot; + rc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam()); + if (SUCCEEDED(rc)) + { + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("Snapshots:\n\n"); + showSnapshots(snapshot, currentSnapshot, details); + } + } + + if (details != VMINFO_MACHINEREADABLE) + RTPrintf("\n"); + return S_OK; +} + +#if defined(_MSC_VER) +# pragma optimize("", on) +# pragma warning(pop) +#endif + +static const RTGETOPTDEF g_aShowVMInfoOptions[] = +{ + { "--details", 'D', RTGETOPT_REQ_NOTHING }, + { "-details", 'D', RTGETOPT_REQ_NOTHING }, // deprecated + { "--machinereadable", 'M', RTGETOPT_REQ_NOTHING }, + { "-machinereadable", 'M', RTGETOPT_REQ_NOTHING }, // deprecated + { "--log", 'l', RTGETOPT_REQ_UINT32 }, +}; + +RTEXITCODE handleShowVMInfo(HandlerArg *a) +{ + HRESULT rc; + const char *VMNameOrUuid = NULL; + bool fLog = false; + uint32_t uLogIdx = 0; + bool fDetails = false; + bool fMachinereadable = false; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aShowVMInfoOptions, RT_ELEMENTS(g_aShowVMInfoOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'D': // --details + fDetails = true; + break; + + case 'M': // --machinereadable + fMachinereadable = true; + break; + + case 'l': // --log + fLog = true; + uLogIdx = ValueUnion.u32; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!VMNameOrUuid) + VMNameOrUuid = ValueUnion.psz; + else + return errorSyntax(USAGE_SHOWVMINFO, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + return errorGetOpt(USAGE_SHOWVMINFO, c, &ValueUnion); + } + } + + /* check for required options */ + if (!VMNameOrUuid) + return errorSyntax(USAGE_SHOWVMINFO, "VM name or UUID required"); + + /* try to find the given machine */ + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(), + machine.asOutParam())); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + /* Printing the log is exclusive. */ + if (fLog && (fMachinereadable || fDetails)) + return errorSyntax(USAGE_SHOWVMINFO, "Option --log is exclusive"); + + if (fLog) + { + ULONG64 uOffset = 0; + SafeArray<BYTE> aLogData; + size_t cbLogData; + while (true) + { + /* Reset the array */ + aLogData.setNull(); + /* Fetch a chunk of the log file */ + CHECK_ERROR_BREAK(machine, ReadLog(uLogIdx, uOffset, _1M, + ComSafeArrayAsOutParam(aLogData))); + cbLogData = aLogData.size(); + if (cbLogData == 0) + break; + /* aLogData has a platform dependent line ending, standardize on + * Unix style, as RTStrmWrite does the LF -> CR/LF replacement on + * Windows. Otherwise we end up with CR/CR/LF on Windows. */ + size_t cbLogDataPrint = cbLogData; + for (BYTE *s = aLogData.raw(), *d = s; + s - aLogData.raw() < (ssize_t)cbLogData; + s++, d++) + { + if (*s == '\r') + { + /* skip over CR, adjust destination */ + d--; + cbLogDataPrint--; + } + else if (s != d) + *d = *s; + } + RTStrmWrite(g_pStdOut, aLogData.raw(), cbLogDataPrint); + uOffset += cbLogData; + } + } + else + { + /* 2nd option can be -details or -argdump */ + VMINFO_DETAILS details = VMINFO_NONE; + if (fMachinereadable) + details = VMINFO_MACHINEREADABLE; + else if (fDetails) + details = VMINFO_FULL; + else + details = VMINFO_STANDARD; + + /* open an existing session for the VM */ + rc = machine->LockMachine(a->session, LockType_Shared); + if (SUCCEEDED(rc)) + /* get the session machine */ + rc = a->session->COMGETTER(Machine)(machine.asOutParam()); + + rc = showVMInfo(a->virtualBox, machine, a->session, details); + + a->session->UnlockMachine(); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +#endif /* !VBOX_ONLY_DOCS */ +/* vi: set tabstop=4 shiftwidth=4 expandtab: */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp new file mode 100644 index 00000000..d5fb8ee2 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp @@ -0,0 +1,1608 @@ +/* $Id: VBoxManageList.cpp $ */ +/** @file + * VBoxManage - The 'list' command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> + +#include <VBox/com/VirtualBox.h> + +#include <VBox/log.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/time.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> + +#include <vector> +#include <algorithm> + +#include "VBoxManage.h" +using namespace com; + +#ifdef VBOX_WITH_HOSTNETIF_API +static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType) +{ + switch (enmType) + { + case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet"; + case HostNetworkInterfaceMediumType_PPP: return "PPP"; + case HostNetworkInterfaceMediumType_SLIP: return "SLIP"; + case HostNetworkInterfaceMediumType_Unknown: return "Unknown"; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + return "unknown"; +} + +static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus) +{ + switch (enmStatus) + { + case HostNetworkInterfaceStatus_Up: return "Up"; + case HostNetworkInterfaceStatus_Down: return "Down"; + case HostNetworkInterfaceStatus_Unknown: return "Unknown"; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + return "unknown"; +} +#endif /* VBOX_WITH_HOSTNETIF_API */ + +static const char*getDeviceTypeText(DeviceType_T enmType) +{ + switch (enmType) + { + case DeviceType_HardDisk: return "HardDisk"; + case DeviceType_DVD: return "DVD"; + case DeviceType_Floppy: return "Floppy"; + /* Make MSC happy */ + case DeviceType_Null: return "Null"; + case DeviceType_Network: return "Network"; + case DeviceType_USB: return "USB"; + case DeviceType_SharedFolder: return "SharedFolder"; + case DeviceType_Graphics3D: return "Graphics3D"; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case DeviceType_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + return "Unknown"; +} + + +/** + * List internal networks. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox) +{ + HRESULT rc; + com::SafeArray<BSTR> internalNetworks; + CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks))); + for (size_t i = 0; i < internalNetworks.size(); ++i) + { + RTPrintf("Name: %ls\n", internalNetworks[i]); + } + return rc; +} + + +/** + * List network interfaces information (bridged/host only). + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + * @param fIsBridged Selects between listing host interfaces (for + * use with bridging) or host only interfaces. + */ +static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox, + bool fIsBridged) +{ + HRESULT rc; + ComPtr<IHost> host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam())); + com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces; +#if defined(VBOX_WITH_NETFLT) + if (fIsBridged) + CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged, + ComSafeArrayAsOutParam(hostNetworkInterfaces))); + else + CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly, + ComSafeArrayAsOutParam(hostNetworkInterfaces))); +#else + RT_NOREF(fIsBridged); + CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces))); +#endif + for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i) + { + ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i]; +#ifndef VBOX_WITH_HOSTNETIF_API + Bstr interfaceName; + networkInterface->COMGETTER(Name)(interfaceName.asOutParam()); + RTPrintf("Name: %ls\n", interfaceName.raw()); + Guid interfaceGuid; + networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam()); + RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw()); +#else /* VBOX_WITH_HOSTNETIF_API */ + Bstr interfaceName; + networkInterface->COMGETTER(Name)(interfaceName.asOutParam()); + RTPrintf("Name: %ls\n", interfaceName.raw()); + Bstr interfaceGuid; + networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam()); + RTPrintf("GUID: %ls\n", interfaceGuid.raw()); + BOOL bDHCPEnabled; + networkInterface->COMGETTER(DHCPEnabled)(&bDHCPEnabled); + RTPrintf("DHCP: %s\n", bDHCPEnabled ? "Enabled" : "Disabled"); + + Bstr IPAddress; + networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam()); + RTPrintf("IPAddress: %ls\n", IPAddress.raw()); + Bstr NetworkMask; + networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam()); + RTPrintf("NetworkMask: %ls\n", NetworkMask.raw()); + Bstr IPV6Address; + networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam()); + RTPrintf("IPV6Address: %ls\n", IPV6Address.raw()); + ULONG IPV6NetworkMaskPrefixLength; + networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength); + RTPrintf("IPV6NetworkMaskPrefixLength: %d\n", IPV6NetworkMaskPrefixLength); + Bstr HardwareAddress; + networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam()); + RTPrintf("HardwareAddress: %ls\n", HardwareAddress.raw()); + HostNetworkInterfaceMediumType_T Type; + networkInterface->COMGETTER(MediumType)(&Type); + RTPrintf("MediumType: %s\n", getHostIfMediumTypeText(Type)); + BOOL fWireless; + networkInterface->COMGETTER(Wireless)(&fWireless); + RTPrintf("Wireless: %s\n", fWireless ? "Yes" : "No"); + HostNetworkInterfaceStatus_T Status; + networkInterface->COMGETTER(Status)(&Status); + RTPrintf("Status: %s\n", getHostIfStatusText(Status)); + Bstr netName; + networkInterface->COMGETTER(NetworkName)(netName.asOutParam()); + RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw()); +#endif + } + return rc; +} + + +/** + * List host information. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox) +{ + static struct + { + ProcessorFeature_T feature; + const char *pszName; + } features[] + = + { + { ProcessorFeature_HWVirtEx, "HW virtualization" }, + { ProcessorFeature_PAE, "PAE" }, + { ProcessorFeature_LongMode, "long mode" }, + { ProcessorFeature_NestedPaging, "nested paging" }, + }; + HRESULT rc; + ComPtr<IHost> Host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam())); + + RTPrintf("Host Information:\n\n"); + + LONG64 u64UtcTime = 0; + CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime)); + RTTIMESPEC timeSpec; + char szTime[32]; + RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime))); + + ULONG processorOnlineCount = 0; + CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount)); + RTPrintf("Processor online count: %lu\n", processorOnlineCount); + ULONG processorCount = 0; + CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount)); + RTPrintf("Processor count: %lu\n", processorCount); + ULONG processorOnlineCoreCount = 0; + CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount)); + RTPrintf("Processor online core count: %lu\n", processorOnlineCoreCount); + ULONG processorCoreCount = 0; + CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount)); + RTPrintf("Processor core count: %lu\n", processorCoreCount); + for (unsigned i = 0; i < RT_ELEMENTS(features); i++) + { + BOOL supported; + CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported)); + RTPrintf("Processor supports %s: %s\n", features[i].pszName, supported ? "yes" : "no"); + } + for (ULONG i = 0; i < processorCount; i++) + { + ULONG processorSpeed = 0; + CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed)); + if (processorSpeed) + RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed); + else + RTPrintf("Processor#%u speed: unknown\n", i); + Bstr processorDescription; + CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam())); + RTPrintf("Processor#%u description: %ls\n", i, processorDescription.raw()); + } + + ULONG memorySize = 0; + CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize)); + RTPrintf("Memory size: %lu MByte\n", memorySize); + + ULONG memoryAvailable = 0; + CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable)); + RTPrintf("Memory available: %lu MByte\n", memoryAvailable); + + Bstr operatingSystem; + CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam())); + RTPrintf("Operating system: %ls\n", operatingSystem.raw()); + + Bstr oSVersion; + CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam())); + RTPrintf("Operating system version: %ls\n", oSVersion.raw()); + return rc; +} + + +/** + * List media information. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + * @param aMedia Medium objects to list information for. + * @param pszParentUUIDStr String with the parent UUID string (or "base"). + * @param fOptLong Long (@c true) or short list format. + */ +static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox, + const com::SafeIfaceArray<IMedium> &aMedia, + const char *pszParentUUIDStr, + bool fOptLong) +{ + HRESULT rc = S_OK; + for (size_t i = 0; i < aMedia.size(); ++i) + { + ComPtr<IMedium> pMedium = aMedia[i]; + + rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong); + + RTPrintf("\n"); + + com::SafeIfaceArray<IMedium> children; + CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children))); + if (children.size() > 0) + { + Bstr uuid; + pMedium->COMGETTER(Id)(uuid.asOutParam()); + + // depth first listing of child media + rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong); + } + } + + return rc; +} + + +/** + * List virtual image backends. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox) +{ + HRESULT rc; + ComPtr<ISystemProperties> systemProperties; + CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam())); + com::SafeIfaceArray<IMediumFormat> mediumFormats; + CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats))); + + RTPrintf("Supported hard disk backends:\n\n"); + for (size_t i = 0; i < mediumFormats.size(); ++i) + { + /* General information */ + Bstr id; + CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam())); + + Bstr description; + CHECK_ERROR(mediumFormats[i], + COMGETTER(Name)(description.asOutParam())); + + ULONG caps = 0; + com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap; + CHECK_ERROR(mediumFormats[i], + COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap))); + for (ULONG j = 0; j < mediumFormatCap.size(); j++) + caps |= mediumFormatCap[j]; + + + RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='", + i, id.raw(), description.raw(), caps); + + /* File extensions */ + com::SafeArray<BSTR> fileExtensions; + com::SafeArray<DeviceType_T> deviceTypes; + CHECK_ERROR(mediumFormats[i], + DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes))); + for (size_t j = 0; j < fileExtensions.size(); ++j) + { + RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j])); + if (j != fileExtensions.size()-1) + RTPrintf(","); + } + RTPrintf("'"); + + /* Configuration keys */ + com::SafeArray<BSTR> propertyNames; + com::SafeArray<BSTR> propertyDescriptions; + com::SafeArray<DataType_T> propertyTypes; + com::SafeArray<ULONG> propertyFlags; + com::SafeArray<BSTR> propertyDefaults; + CHECK_ERROR(mediumFormats[i], + DescribeProperties(ComSafeArrayAsOutParam(propertyNames), + ComSafeArrayAsOutParam(propertyDescriptions), + ComSafeArrayAsOutParam(propertyTypes), + ComSafeArrayAsOutParam(propertyFlags), + ComSafeArrayAsOutParam(propertyDefaults))); + + RTPrintf(" properties=("); + if (propertyNames.size() > 0) + { + for (size_t j = 0; j < propertyNames.size(); ++j) + { + RTPrintf("\n name='%ls' desc='%ls' type=", + Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw()); + switch (propertyTypes[j]) + { + case DataType_Int32: RTPrintf("int"); break; + case DataType_Int8: RTPrintf("byte"); break; + case DataType_String: RTPrintf("string"); break; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case DataType_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + RTPrintf(" flags=%#04x", propertyFlags[j]); + RTPrintf(" default='%ls'", Bstr(propertyDefaults[j]).raw()); + if (j != propertyNames.size()-1) + RTPrintf(", "); + } + } + RTPrintf(")\n"); + } + return rc; +} + + +/** + * List USB devices attached to the host. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox) +{ + HRESULT rc; + ComPtr<IHost> Host; + CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1); + + SafeIfaceArray<IHostUSBDevice> CollPtr; + CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1); + + RTPrintf("Host USB Devices:\n\n"); + + if (CollPtr.size() == 0) + { + RTPrintf("<none>\n\n"); + } + else + { + for (size_t i = 0; i < CollPtr.size(); ++i) + { + ComPtr<IHostUSBDevice> dev = CollPtr[i]; + + /* Query info. */ + Bstr id; + CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1); + USHORT usVendorId; + CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1); + USHORT usProductId; + CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1); + USHORT bcdRevision; + CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1); + USHORT usPort; + CHECK_ERROR_RET(dev, COMGETTER(Port)(&usPort), 1); + USHORT usVersion; + CHECK_ERROR_RET(dev, COMGETTER(Version)(&usVersion), 1); + USHORT usPortVersion; + CHECK_ERROR_RET(dev, COMGETTER(PortVersion)(&usPortVersion), 1); + USBConnectionSpeed_T enmSpeed; + CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1); + + RTPrintf("UUID: %s\n" + "VendorId: %#06x (%04X)\n" + "ProductId: %#06x (%04X)\n" + "Revision: %u.%u (%02u%02u)\n" + "Port: %u\n", + Utf8Str(id).c_str(), + usVendorId, usVendorId, usProductId, usProductId, + bcdRevision >> 8, bcdRevision & 0xff, + bcdRevision >> 8, bcdRevision & 0xff, + usPort); + + const char *pszSpeed = "?"; + switch (enmSpeed) + { + case USBConnectionSpeed_Low: + pszSpeed = "Low"; + break; + case USBConnectionSpeed_Full: + pszSpeed = "Full"; + break; + case USBConnectionSpeed_High: + pszSpeed = "High"; + break; + case USBConnectionSpeed_Super: + pszSpeed = "Super"; + break; + case USBConnectionSpeed_SuperPlus: + pszSpeed = "SuperPlus"; + break; + default: + ASSERT(false); + break; + } + + RTPrintf("USB version/speed: %u/%s\n", usVersion, pszSpeed); + + /* optional stuff. */ + SafeArray<BSTR> CollDevInfo; + Bstr bstr; + CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1); + if (CollDevInfo.size() >= 1) + bstr = Bstr(CollDevInfo[0]); + if (!bstr.isEmpty()) + RTPrintf("Manufacturer: %ls\n", bstr.raw()); + if (CollDevInfo.size() >= 2) + bstr = Bstr(CollDevInfo[1]); + if (!bstr.isEmpty()) + RTPrintf("Product: %ls\n", bstr.raw()); + CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1); + if (!bstr.isEmpty()) + RTPrintf("SerialNumber: %ls\n", bstr.raw()); + CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1); + if (!bstr.isEmpty()) + RTPrintf("Address: %ls\n", bstr.raw()); + + /* current state */ + USBDeviceState_T state; + CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1); + const char *pszState = "?"; + switch (state) + { + case USBDeviceState_NotSupported: + pszState = "Not supported"; + break; + case USBDeviceState_Unavailable: + pszState = "Unavailable"; + break; + case USBDeviceState_Busy: + pszState = "Busy"; + break; + case USBDeviceState_Available: + pszState = "Available"; + break; + case USBDeviceState_Held: + pszState = "Held"; + break; + case USBDeviceState_Captured: + pszState = "Captured"; + break; + default: + ASSERT(false); + break; + } + RTPrintf("Current State: %s\n\n", pszState); + } + } + return rc; +} + + +/** + * List USB filters. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox) +{ + HRESULT rc; + + RTPrintf("Global USB Device Filters:\n\n"); + + ComPtr<IHost> host; + CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(host.asOutParam()), 1); + + SafeIfaceArray<IHostUSBDeviceFilter> coll; + CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1); + + if (coll.size() == 0) + { + RTPrintf("<none>\n\n"); + } + else + { + for (size_t index = 0; index < coll.size(); ++index) + { + ComPtr<IHostUSBDeviceFilter> flt = coll[index]; + + /* Query info. */ + + RTPrintf("Index: %zu\n", index); + + BOOL active = FALSE; + CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1); + RTPrintf("Active: %s\n", active ? "yes" : "no"); + + USBDeviceFilterAction_T action; + CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1); + const char *pszAction = "<invalid>"; + switch (action) + { + case USBDeviceFilterAction_Ignore: + pszAction = "Ignore"; + break; + case USBDeviceFilterAction_Hold: + pszAction = "Hold"; + break; + default: + break; + } + RTPrintf("Action: %s\n", pszAction); + + Bstr bstr; + CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1); + RTPrintf("Name: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1); + RTPrintf("VendorId: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1); + RTPrintf("ProductId: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1); + RTPrintf("Revision: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1); + RTPrintf("Manufacturer: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1); + RTPrintf("Product: %ls\n", bstr.raw()); + CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1); + RTPrintf("Serial Number: %ls\n\n", bstr.raw()); + } + } + return rc; +} + + +/** + * List system properties. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox) +{ + ComPtr<ISystemProperties> systemProperties; + CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck); + + Bstr str; + ULONG ulValue; + LONG64 i64Value; + BOOL fValue; + const char *psz; + + pVirtualBox->COMGETTER(APIVersion)(str.asOutParam()); + RTPrintf("API version: %ls\n", str.raw()); + + systemProperties->COMGETTER(MinGuestRAM)(&ulValue); + RTPrintf("Minimum guest RAM size: %u Megabytes\n", ulValue); + systemProperties->COMGETTER(MaxGuestRAM)(&ulValue); + RTPrintf("Maximum guest RAM size: %u Megabytes\n", ulValue); + systemProperties->COMGETTER(MinGuestVRAM)(&ulValue); + RTPrintf("Minimum video RAM size: %u Megabytes\n", ulValue); + systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue); + RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue); + systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue); + RTPrintf("Maximum guest monitor count: %u\n", ulValue); + systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue); + RTPrintf("Minimum guest CPU count: %u\n", ulValue); + systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue); + RTPrintf("Maximum guest CPU count: %u\n", ulValue); + systemProperties->COMGETTER(InfoVDSize)(&i64Value); + RTPrintf("Virtual disk limit (info): %lld Bytes\n", i64Value); + systemProperties->COMGETTER(SerialPortCount)(&ulValue); + RTPrintf("Maximum Serial Port count: %u\n", ulValue); + systemProperties->COMGETTER(ParallelPortCount)(&ulValue); + RTPrintf("Maximum Parallel Port count: %u\n", ulValue); + systemProperties->COMGETTER(MaxBootPosition)(&ulValue); + RTPrintf("Maximum Boot Position: %u\n", ulValue); + systemProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue); + RTPrintf("Maximum PIIX3 Network Adapter count: %u\n", ulValue); + systemProperties->GetMaxNetworkAdapters(ChipsetType_ICH9, &ulValue); + RTPrintf("Maximum ICH9 Network Adapter count: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue); + RTPrintf("Maximum PIIX3 IDE Controllers: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue); + RTPrintf("Maximum ICH9 IDE Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue); + RTPrintf("Maximum IDE Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue); + RTPrintf("Maximum Devices per IDE Port: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue); + RTPrintf("Maximum PIIX3 SATA Controllers: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue); + RTPrintf("Maximum ICH9 SATA Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue); + RTPrintf("Maximum SATA Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue); + RTPrintf("Maximum Devices per SATA Port: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue); + RTPrintf("Maximum PIIX3 SCSI Controllers: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue); + RTPrintf("Maximum ICH9 SCSI Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue); + RTPrintf("Maximum SCSI Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue); + RTPrintf("Maximum Devices per SCSI Port: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue); + RTPrintf("Maximum SAS PIIX3 Controllers: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue); + RTPrintf("Maximum SAS ICH9 Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue); + RTPrintf("Maximum SAS Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue); + RTPrintf("Maximum Devices per SAS Port: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue); + RTPrintf("Maximum NVMe PIIX3 Controllers: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue); + RTPrintf("Maximum NVMe ICH9 Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue); + RTPrintf("Maximum NVMe Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue); + RTPrintf("Maximum Devices per NVMe Port: %u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue); + RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue); + systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue); + RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue); + systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue); + RTPrintf("Maximum Floppy Port count: %u\n", ulValue); + systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue); + RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue); +#if 0 + systemProperties->GetFreeDiskSpaceWarning(&i64Value); + RTPrintf("Free disk space warning at: %u Bytes\n", i64Value); + systemProperties->GetFreeDiskSpacePercentWarning(&ulValue); + RTPrintf("Free disk space warning at: %u %%\n", ulValue); + systemProperties->GetFreeDiskSpaceError(&i64Value); + RTPrintf("Free disk space error at: %u Bytes\n", i64Value); + systemProperties->GetFreeDiskSpacePercentError(&ulValue); + RTPrintf("Free disk space error at: %u %%\n", ulValue); +#endif + systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam()); + RTPrintf("Default machine folder: %ls\n", str.raw()); + systemProperties->COMGETTER(RawModeSupported)(&fValue); + RTPrintf("Raw-mode Supported: %s\n", fValue ? "yes" : "no"); + systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue); + RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off"); + systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam()); + RTPrintf("Default hard disk format: %ls\n", str.raw()); + systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam()); + RTPrintf("VRDE auth library: %ls\n", str.raw()); + systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam()); + RTPrintf("Webservice auth. library: %ls\n", str.raw()); + systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam()); + RTPrintf("Remote desktop ExtPack: %ls\n", str.raw()); + systemProperties->COMGETTER(LogHistoryCount)(&ulValue); + RTPrintf("Log history count: %u\n", ulValue); + systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam()); + RTPrintf("Default frontend: %ls\n", str.raw()); + AudioDriverType_T enmAudio; + systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio); + switch (enmAudio) + { + case AudioDriverType_Null: psz = "Null"; break; + case AudioDriverType_WinMM: psz = "WinMM"; break; + case AudioDriverType_OSS: psz = "OSS"; break; + case AudioDriverType_ALSA: psz = "ALSA"; break; + case AudioDriverType_DirectSound: psz = "DirectSound"; break; + case AudioDriverType_CoreAudio: psz = "CoreAudio"; break; + case AudioDriverType_MMPM: psz = "MMPM"; break; + case AudioDriverType_Pulse: psz = "Pulse"; break; + case AudioDriverType_SolAudio: psz = "SolAudio"; break; + default: psz = "Unknown"; + } + RTPrintf("Default audio driver: %s\n", psz); + systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam()); + RTPrintf("Autostart database path: %ls\n", str.raw()); + systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam()); + RTPrintf("Default Guest Additions ISO: %ls\n", str.raw()); + systemProperties->COMGETTER(LoggingLevel)(str.asOutParam()); + RTPrintf("Logging Level: %ls\n", str.raw()); + ProxyMode_T enmProxyMode = (ProxyMode_T)42; + systemProperties->COMGETTER(ProxyMode)(&enmProxyMode); + psz = "Unknown"; + switch (enmProxyMode) + { + case ProxyMode_System: psz = "System"; break; + case ProxyMode_NoProxy: psz = "NoProxy"; break; + case ProxyMode_Manual: psz = "Manual"; break; +#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK + case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */ +#endif + } + RTPrintf("Proxy Mode: %s\n", psz); + systemProperties->COMGETTER(ProxyURL)(str.asOutParam()); + RTPrintf("Proxy URL: %ls\n", str.raw()); + return S_OK; +} + + +/** + * Helper function for querying and displaying DHCP option for an adapter. + * + * @returns See produceList. + * @param pSrv Smart pointer to IDHCPServer. + * @param vmSlot String identifying the adapter, like '[vmname]:slot' + */ +static HRESULT listVmSlotDhcpOptions(const ComPtr<IDHCPServer> pSrv, const Utf8Str& vmSlot) +{ + RTCList<RTCString> lstParts = vmSlot.split(":"); + if (lstParts.size() < 2) + return E_INVALIDARG; + if (lstParts[0].length() < 2 || !lstParts[0].startsWith("[") || !lstParts[0].endsWith("]")) + return E_INVALIDARG; + Bstr vmName(lstParts[0].substr(1, lstParts[0].length()-2)); + ULONG uSlot = lstParts[1].toUInt32(); + com::SafeArray<BSTR> options; + CHECK_ERROR2I_RET(pSrv, GetVmSlotOptions(vmName.raw(), uSlot, ComSafeArrayAsOutParam(options)), hrcCheck); + if (options.size()) + RTPrintf("Options for NIC %d of '%ls':\n", uSlot + 1, vmName.raw()); + for (size_t i = 0; i < options.size(); ++i) + RTPrintf(" %ls\n", options[i]); + + return S_OK; +} + + +/** + * List DHCP servers. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox) +{ + HRESULT rc = S_OK; + com::SafeIfaceArray<IDHCPServer> svrs; + CHECK_ERROR_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)), rc); + for (size_t i = 0; i < svrs.size(); ++i) + { + ComPtr<IDHCPServer> svr = svrs[i]; + Bstr netName; + svr->COMGETTER(NetworkName)(netName.asOutParam()); + RTPrintf("NetworkName: %ls\n", netName.raw()); + Bstr ip; + svr->COMGETTER(IPAddress)(ip.asOutParam()); + RTPrintf("IP: %ls\n", ip.raw()); + Bstr netmask; + svr->COMGETTER(NetworkMask)(netmask.asOutParam()); + RTPrintf("NetworkMask: %ls\n", netmask.raw()); + Bstr lowerIp; + svr->COMGETTER(LowerIP)(lowerIp.asOutParam()); + RTPrintf("lowerIPAddress: %ls\n", lowerIp.raw()); + Bstr upperIp; + svr->COMGETTER(UpperIP)(upperIp.asOutParam()); + RTPrintf("upperIPAddress: %ls\n", upperIp.raw()); + BOOL fEnabled; + svr->COMGETTER(Enabled)(&fEnabled); + RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No"); + com::SafeArray<BSTR> globalOptions; + CHECK_ERROR_BREAK(svr, COMGETTER(GlobalOptions)(ComSafeArrayAsOutParam(globalOptions))); + if (globalOptions.size()) + { + RTPrintf("Global options:\n"); + for (size_t j = 0; j < globalOptions.size(); ++j) + RTPrintf(" %ls\n", globalOptions[j]); + } + com::SafeArray<BSTR> vmConfigs; + CHECK_ERROR_BREAK(svr, COMGETTER(VmConfigs)(ComSafeArrayAsOutParam(vmConfigs))); + for (size_t j = 0; j < vmConfigs.size(); ++j) + { + rc = listVmSlotDhcpOptions(svr, vmConfigs[j]); + if (FAILED(rc)) + break; + } + RTPrintf("\n"); + } + + return rc; +} + +/** + * List extension packs. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox) +{ + ComObjPtr<IExtPackManager> ptrExtPackMgr; + CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck); + + SafeIfaceArray<IExtPack> extPacks; + CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck); + RTPrintf("Extension Packs: %u\n", extPacks.size()); + + HRESULT hrc = S_OK; + for (size_t i = 0; i < extPacks.size(); i++) + { + /* Read all the properties. */ + Bstr bstrName; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull()); + Bstr bstrDesc; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull()); + Bstr bstrVersion; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull()); + ULONG uRevision; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0); + Bstr bstrEdition; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull()); + Bstr bstrVrdeModule; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull()); + BOOL fUsable; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE); + Bstr bstrWhy; + CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull()); + + /* Display them. */ + if (i) + RTPrintf("\n"); + RTPrintf("Pack no.%2zu: %ls\n" + "Version: %ls\n" + "Revision: %u\n" + "Edition: %ls\n" + "Description: %ls\n" + "VRDE Module: %ls\n" + "Usable: %RTbool\n" + "Why unusable: %ls\n", + i, bstrName.raw(), + bstrVersion.raw(), + uRevision, + bstrEdition.raw(), + bstrDesc.raw(), + bstrVrdeModule.raw(), + fUsable != FALSE, + bstrWhy.raw()); + + /* Query plugins and display them. */ + } + return hrc; +} + + +/** + * List machine groups. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox) +{ + SafeArray<BSTR> groups; + CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck); + + for (size_t i = 0; i < groups.size(); i++) + { + RTPrintf("\"%ls\"\n", groups[i]); + } + return S_OK; +} + + +/** + * List video capture devices. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox pointer. + */ +static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox) +{ + HRESULT rc; + ComPtr<IHost> host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam())); + com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices; + CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices))); + RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size()); + for (size_t i = 0; i < hostVideoInputDevices.size(); ++i) + { + ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i]; + Bstr name; + p->COMGETTER(Name)(name.asOutParam()); + Bstr path; + p->COMGETTER(Path)(path.asOutParam()); + Bstr alias; + p->COMGETTER(Alias)(alias.asOutParam()); + RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw()); + } + return rc; +} + +/** + * List supported screen shot formats. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox pointer. + */ +static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> pVirtualBox) +{ + HRESULT rc = S_OK; + ComPtr<ISystemProperties> systemProperties; + CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam())); + com::SafeArray<BitmapFormat_T> formats; + CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats))); + + RTPrintf("Supported %d screen shot formats:\n", formats.size()); + for (size_t i = 0; i < formats.size(); ++i) + { + uint32_t u32Format = (uint32_t)formats[i]; + char szFormat[5]; + szFormat[0] = RT_BYTE1(u32Format); + szFormat[1] = RT_BYTE2(u32Format); + szFormat[2] = RT_BYTE3(u32Format); + szFormat[3] = RT_BYTE4(u32Format); + szFormat[4] = 0; + RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format); + } + return rc; +} + +/** + * List available cloud providers. + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox pointer. + */ +static HRESULT listCloudProviders(const ComPtr<IVirtualBox> pVirtualBox) +{ + HRESULT rc = S_OK; + ComPtr<ICloudProviderManager> pCloudProviderManager; + CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam())); + com::SafeIfaceArray<ICloudProvider> apCloudProviders; + CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders))); + + RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size()); + for (size_t i = 0; i < apCloudProviders.size(); ++i) + { + ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i]; + Bstr bstrProviderName; + pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam()); + RTPrintf("Name: %ls\n", bstrProviderName.raw()); + pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam()); + RTPrintf("Short Name: %ls\n", bstrProviderName.raw()); + Bstr bstrProviderID; + pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam()); + RTPrintf("GUID: %ls\n", bstrProviderID.raw()); + + RTPrintf("\n"); + } + return rc; +} + + +/** + * List all available cloud profiles (by iterating over the cloud providers). + * + * @returns See produceList. + * @param pVirtualBox Reference to the IVirtualBox pointer. + * @param fOptLong If true, list all profile properties. + */ +static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong) +{ + HRESULT rc = S_OK; + ComPtr<ICloudProviderManager> pCloudProviderManager; + CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam())); + com::SafeIfaceArray<ICloudProvider> apCloudProviders; + CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders))); + + for (size_t i = 0; i < apCloudProviders.size(); ++i) + { + ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i]; + com::SafeIfaceArray<ICloudProfile> apCloudProfiles; + CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles))); + for (size_t j = 0; j < apCloudProfiles.size(); ++j) + { + ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j]; + Bstr bstrProfileName; + pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam()); + RTPrintf("Name: %ls\n", bstrProfileName.raw()); + Bstr bstrProviderID; + pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam()); + RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw()); + + if (fOptLong) + { + com::SafeArray<BSTR> names; + com::SafeArray<BSTR> values; + pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values)); + size_t cNames = names.size(); + size_t cValues = values.size(); + bool fFirst = true; + for (size_t k = 0; k < cNames; k++) + { + Bstr value; + if (k < cValues) + value = values[k]; + RTPrintf("%s%ls=%ls\n", + fFirst ? "Property: " : " ", + names[k], value.raw()); + fFirst = false; + } + } + + RTPrintf("\n"); + } + } + return rc; +} + + +/** + * The type of lists we can produce. + */ +enum enmListType +{ + kListNotSpecified = 1000, + kListVMs, + kListRunningVMs, + kListOsTypes, + kListHostDvds, + kListHostFloppies, + kListInternalNetworks, + kListBridgedInterfaces, +#if defined(VBOX_WITH_NETFLT) + kListHostOnlyInterfaces, +#endif + kListHostCpuIDs, + kListHostInfo, + kListHddBackends, + kListHdds, + kListDvds, + kListFloppies, + kListUsbHost, + kListUsbFilters, + kListSystemProperties, + kListDhcpServers, + kListExtPacks, + kListGroups, + kListNatNetworks, + kListVideoInputDevices, + kListScreenShotFormats, + kListCloudProviders, + kListCloudProfiles, +}; + + +/** + * Produces the specified listing. + * + * @returns S_OK or some COM error code that has been reported in full. + * @param enmList The list to produce. + * @param fOptLong Long (@c true) or short list format. + * @param pVirtualBox Reference to the IVirtualBox smart pointer. + */ +static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox) +{ + HRESULT rc = S_OK; + switch (enmCommand) + { + case kListNotSpecified: + AssertFailed(); + return E_FAIL; + + case kListVMs: + { + /* + * Get the list of all registered VMs + */ + com::SafeIfaceArray<IMachine> machines; + rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)); + if (SUCCEEDED(rc)) + { + /* + * Display it. + */ + if (!fOptSorted) + { + for (size_t i = 0; i < machines.size(); ++i) + if (machines[i]) + rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT); + } + else + { + /* + * Sort the list by name before displaying it. + */ + std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines; + for (size_t i = 0; i < machines.size(); ++i) + { + IMachine *pMachine = machines[i]; + if (pMachine) /* no idea why we need to do this... */ + { + Bstr bstrName; + pMachine->COMGETTER(Name)(bstrName.asOutParam()); + sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine)); + } + } + + std::sort(sortedMachines.begin(), sortedMachines.end()); + + for (size_t i = 0; i < sortedMachines.size(); ++i) + rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT); + } + } + break; + } + + case kListRunningVMs: + { + /* + * Get the list of all _running_ VMs + */ + com::SafeIfaceArray<IMachine> machines; + rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines)); + com::SafeArray<MachineState_T> states; + if (SUCCEEDED(rc)) + rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states)); + if (SUCCEEDED(rc)) + { + /* + * Iterate through the collection + */ + for (size_t i = 0; i < machines.size(); ++i) + { + if (machines[i]) + { + MachineState_T machineState = states[i]; + switch (machineState) + { + case MachineState_Running: + case MachineState_Teleporting: + case MachineState_LiveSnapshotting: + case MachineState_Paused: + case MachineState_TeleportingPausedVM: + rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT); + break; + default: break; /* Shut up MSC */ + } + } + } + } + break; + } + + case kListOsTypes: + { + com::SafeIfaceArray<IGuestOSType> coll; + rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll)); + if (SUCCEEDED(rc)) + { + /* + * Iterate through the collection. + */ + for (size_t i = 0; i < coll.size(); ++i) + { + ComPtr<IGuestOSType> guestOS; + guestOS = coll[i]; + Bstr guestId; + guestOS->COMGETTER(Id)(guestId.asOutParam()); + RTPrintf("ID: %ls\n", guestId.raw()); + Bstr guestDescription; + guestOS->COMGETTER(Description)(guestDescription.asOutParam()); + RTPrintf("Description: %ls\n", guestDescription.raw()); + Bstr familyId; + guestOS->COMGETTER(FamilyId)(familyId.asOutParam()); + RTPrintf("Family ID: %ls\n", familyId.raw()); + Bstr familyDescription; + guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam()); + RTPrintf("Family Desc: %ls\n", familyDescription.raw()); + BOOL is64Bit; + guestOS->COMGETTER(Is64Bit)(&is64Bit); + RTPrintf("64 bit: %RTbool\n", is64Bit); + RTPrintf("\n"); + } + } + break; + } + + case kListHostDvds: + { + ComPtr<IHost> host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam())); + com::SafeIfaceArray<IMedium> coll; + CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll))); + if (SUCCEEDED(rc)) + { + for (size_t i = 0; i < coll.size(); ++i) + { + ComPtr<IMedium> dvdDrive = coll[i]; + Bstr uuid; + dvdDrive->COMGETTER(Id)(uuid.asOutParam()); + RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str()); + Bstr location; + dvdDrive->COMGETTER(Location)(location.asOutParam()); + RTPrintf("Name: %ls\n\n", location.raw()); + } + } + break; + } + + case kListHostFloppies: + { + ComPtr<IHost> host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam())); + com::SafeIfaceArray<IMedium> coll; + CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll))); + if (SUCCEEDED(rc)) + { + for (size_t i = 0; i < coll.size(); ++i) + { + ComPtr<IMedium> floppyDrive = coll[i]; + Bstr uuid; + floppyDrive->COMGETTER(Id)(uuid.asOutParam()); + RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str()); + Bstr location; + floppyDrive->COMGETTER(Location)(location.asOutParam()); + RTPrintf("Name: %ls\n\n", location.raw()); + } + } + break; + } + + case kListInternalNetworks: + rc = listInternalNetworks(pVirtualBox); + break; + + case kListBridgedInterfaces: +#if defined(VBOX_WITH_NETFLT) + case kListHostOnlyInterfaces: +#endif + rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces); + break; + + case kListHostInfo: + rc = listHostInfo(pVirtualBox); + break; + + case kListHostCpuIDs: + { + ComPtr<IHost> Host; + CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam())); + + RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n"); + ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */ + static uint32_t const s_auCpuIdRanges[] = + { + UINT32_C(0x00000000), UINT32_C(0x0000007f), + UINT32_C(0x80000000), UINT32_C(0x8000007f), + UINT32_C(0xc0000000), UINT32_C(0xc000007f) + }; + for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2) + { + ULONG uEAX, uEBX, uECX, uEDX, cLeafs; + CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX)); + if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1]) + continue; + cLeafs++; + for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++) + { + CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX)); + RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX); + } + } + break; + } + + case kListHddBackends: + rc = listHddBackends(pVirtualBox); + break; + + case kListHdds: + { + com::SafeIfaceArray<IMedium> hdds; + CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds))); + rc = listMedia(pVirtualBox, hdds, "base", fOptLong); + break; + } + + case kListDvds: + { + com::SafeIfaceArray<IMedium> dvds; + CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds))); + rc = listMedia(pVirtualBox, dvds, NULL, fOptLong); + break; + } + + case kListFloppies: + { + com::SafeIfaceArray<IMedium> floppies; + CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies))); + rc = listMedia(pVirtualBox, floppies, NULL, fOptLong); + break; + } + + case kListUsbHost: + rc = listUsbHost(pVirtualBox); + break; + + case kListUsbFilters: + rc = listUsbFilters(pVirtualBox); + break; + + case kListSystemProperties: + rc = listSystemProperties(pVirtualBox); + break; + + case kListDhcpServers: + rc = listDhcpServers(pVirtualBox); + break; + + case kListExtPacks: + rc = listExtensionPacks(pVirtualBox); + break; + + case kListGroups: + rc = listGroups(pVirtualBox); + break; + + case kListNatNetworks: + { + com::SafeIfaceArray<INATNetwork> nets; + CHECK_ERROR(pVirtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nets))); + for (size_t i = 0; i < nets.size(); ++i) + { + ComPtr<INATNetwork> net = nets[i]; + Bstr netName; + net->COMGETTER(NetworkName)(netName.asOutParam()); + RTPrintf("NetworkName: %ls\n", netName.raw()); + Bstr gateway; + net->COMGETTER(Gateway)(gateway.asOutParam()); + RTPrintf("IP: %ls\n", gateway.raw()); + Bstr network; + net->COMGETTER(Network)(network.asOutParam()); + RTPrintf("Network: %ls\n", network.raw()); + BOOL fEnabled; + net->COMGETTER(IPv6Enabled)(&fEnabled); + RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No"); + Bstr ipv6prefix; + net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam()); + RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw()); + net->COMGETTER(NeedDhcpServer)(&fEnabled); + RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No"); + net->COMGETTER(Enabled)(&fEnabled); + RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No"); + +#define PRINT_STRING_ARRAY(title) \ + if (strs.size() > 0) \ + { \ + RTPrintf(title); \ + size_t j = 0; \ + for (;j < strs.size(); ++j) \ + RTPrintf(" %s\n", Utf8Str(strs[j]).c_str()); \ + } + + com::SafeArray<BSTR> strs; + + CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs))); + PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n"); + strs.setNull(); + + CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs))); + PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n"); + strs.setNull(); + + CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs))); + PRINT_STRING_ARRAY("loopback mappings (ipv4)\n"); + strs.setNull(); + +#undef PRINT_STRING_ARRAY + RTPrintf("\n"); + } + break; + } + + case kListVideoInputDevices: + rc = listVideoInputDevices(pVirtualBox); + break; + + case kListScreenShotFormats: + rc = listScreenShotFormats(pVirtualBox); + break; + + case kListCloudProviders: + rc = listCloudProviders(pVirtualBox); + break; + + case kListCloudProfiles: + rc = listCloudProfiles(pVirtualBox, fOptLong); + break; + + /* No default here, want gcc warnings. */ + + } /* end switch */ + + return rc; +} + +/** + * Handles the 'list' command. + * + * @returns Appropriate exit code. + * @param a Handler argument. + */ +RTEXITCODE handleList(HandlerArg *a) +{ + bool fOptLong = false; + bool fOptMultiple = false; + bool fOptSorted = false; + enum enmListType enmOptCommand = kListNotSpecified; + + static const RTGETOPTDEF s_aListOptions[] = + { + { "--long", 'l', RTGETOPT_REQ_NOTHING }, + { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */ + { "--sorted", 's', RTGETOPT_REQ_NOTHING }, + { "vms", kListVMs, RTGETOPT_REQ_NOTHING }, + { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING }, + { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING }, + { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING }, + { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING }, + { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING }, + { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */ + { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, +#if defined(VBOX_WITH_NETFLT) + { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING }, +#endif + { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING }, + { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING }, + { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING }, + { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING }, + { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING }, + { "hdds", kListHdds, RTGETOPT_REQ_NOTHING }, + { "dvds", kListDvds, RTGETOPT_REQ_NOTHING }, + { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING }, + { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING }, + { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING }, + { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING }, + { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING }, + { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING }, + { "groups", kListGroups, RTGETOPT_REQ_NOTHING }, + { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING }, + { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING }, + { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING }, + { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING }, + }; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((ch = RTGetOpt(&GetState, &ValueUnion))) + { + switch (ch) + { + case 'l': /* --long */ + fOptLong = true; + break; + + case 's': + fOptSorted = true; + break; + + case 'm': + fOptMultiple = true; + if (enmOptCommand == kListNotSpecified) + break; + ch = enmOptCommand; + RT_FALL_THRU(); + + case kListVMs: + case kListRunningVMs: + case kListOsTypes: + case kListHostDvds: + case kListHostFloppies: + case kListInternalNetworks: + case kListBridgedInterfaces: +#if defined(VBOX_WITH_NETFLT) + case kListHostOnlyInterfaces: +#endif + case kListHostInfo: + case kListHostCpuIDs: + case kListHddBackends: + case kListHdds: + case kListDvds: + case kListFloppies: + case kListUsbHost: + case kListUsbFilters: + case kListSystemProperties: + case kListDhcpServers: + case kListExtPacks: + case kListGroups: + case kListNatNetworks: + case kListVideoInputDevices: + case kListScreenShotFormats: + case kListCloudProviders: + case kListCloudProfiles: + enmOptCommand = (enum enmListType)ch; + if (fOptMultiple) + { + HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox); + if (FAILED(hrc)) + return RTEXITCODE_FAILURE; + } + break; + + case VINF_GETOPT_NOT_OPTION: + return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz); + + default: + return errorGetOpt(USAGE_LIST, ch, &ValueUnion); + } + } + + /* + * If not in multiple list mode, we have to produce the list now. + */ + if (enmOptCommand == kListNotSpecified) + return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n"); + if (!fOptMultiple) + { + HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox); + if (FAILED(hrc)) + return RTEXITCODE_FAILURE; + } + + return RTEXITCODE_SUCCESS; +} + +#endif /* !VBOX_ONLY_DOCS */ +/* vi: set tabstop=4 shiftwidth=4 expandtab: */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp new file mode 100644 index 00000000..3f655c47 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageMetrics.cpp @@ -0,0 +1,651 @@ +/* $Id: VBoxManageMetrics.cpp $ */ +/** @file + * VBoxManage - The 'metrics' command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/asm.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/time.h> +#include <iprt/thread.h> +#include <VBox/log.h> + +#include <set> +#include <utility> + +#include "VBoxManage.h" +using namespace com; + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + + +static HRESULT parseFilterParameters(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComSafeArrayOut(BSTR, outMetrics), + ComSafeArrayOut(IUnknown *, outObjects)) +{ + HRESULT rc = S_OK; + com::SafeArray<BSTR> retMetrics(1); + com::SafeIfaceArray <IUnknown> retObjects; + + Bstr metricNames, baseNames; + + /* Metric list */ + if (argc > 1) + metricNames = argv[1]; + else + { + metricNames = L"*"; + baseNames = L"*"; + } + metricNames.cloneTo(&retMetrics[0]); + + /* Object name */ + if (argc > 0 && strcmp(argv[0], "*")) + { + if (!strcmp(argv[0], "host")) + { + ComPtr<IHost> host; + CHECK_ERROR(aVirtualBox, COMGETTER(Host)(host.asOutParam())); + retObjects.reset(1); + host.queryInterfaceTo(&retObjects[0]); + } + else + { + ComPtr<IMachine> machine; + rc = aVirtualBox->FindMachine(Bstr(argv[0]).raw(), + machine.asOutParam()); + if (SUCCEEDED(rc)) + { + retObjects.reset(1); + machine.queryInterfaceTo(&retObjects[0]); + } + else + { + errorArgument("Invalid machine name: '%s'", argv[0]); + return rc; + } + } + + } + + retMetrics.detachTo(ComSafeArrayOutArg(outMetrics)); + retObjects.detachTo(ComSafeArrayOutArg(outObjects)); + + return rc; +} + +static Bstr toBaseName(Utf8Str& aFullName) +{ + char *pszRaw = aFullName.mutableRaw(); + /* + * Currently there are two metrics which base name is the same as the + * sub-metric name: CPU/MHz and Net/<iface>/LinkSpeed. + */ + if (pszRaw && strcmp(pszRaw, "CPU/MHz") && !RTStrSimplePatternMatch("Net/*/LinkSpeed", pszRaw)) + { + char *pszSlash = strrchr(pszRaw, '/'); + if (pszSlash) + { + *pszSlash = 0; + aFullName.jolt(); + } + } + return Bstr(aFullName); +} + +static Bstr getObjectName(ComPtr<IUnknown> aObject) +{ + HRESULT rc; + + ComPtr<IHost> host = aObject; + if (!host.isNull()) + return Bstr("host"); + + ComPtr<IMachine> machine = aObject; + if (!machine.isNull()) + { + Bstr name; + CHECK_ERROR(machine, COMGETTER(Name)(name.asOutParam())); + if (SUCCEEDED(rc)) + return name; + } + return Bstr("unknown"); +} + +static void listAffectedMetrics(ComSafeArrayIn(IPerformanceMetric*, aMetrics)) +{ + HRESULT rc; + com::SafeIfaceArray<IPerformanceMetric> metrics(ComSafeArrayInArg(aMetrics)); + if (metrics.size()) + { + ComPtr<IUnknown> object; + Bstr metricName; + RTPrintf("The following metrics were modified:\n\n" + "Object Metric\n" + "---------- --------------------\n"); + for (size_t i = 0; i < metrics.size(); i++) + { + CHECK_ERROR(metrics[i], COMGETTER(Object)(object.asOutParam())); + CHECK_ERROR(metrics[i], COMGETTER(MetricName)(metricName.asOutParam())); + RTPrintf("%-10ls %-20ls\n", + getObjectName(object).raw(), metricName.raw()); + } + RTPrintf("\n"); + } + else + { + RTMsgError("No metrics match the specified filter!"); + } +} + +/** + * list + */ +static RTEXITCODE handleMetricsList(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + + rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeIfaceArray<IPerformanceMetric> metricInfo; + + CHECK_ERROR(performanceCollector, + GetMetrics(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(metricInfo))); + + ComPtr<IUnknown> object; + Bstr metricName, unit, description; + ULONG period, count; + LONG minimum, maximum; + RTPrintf( +"Object Metric Unit Minimum Maximum Period Count Description\n" +"--------------- ---------------------------------------- ---- ---------- ---------- ---------- ---------- -----------\n"); + for (size_t i = 0; i < metricInfo.size(); i++) + { + CHECK_ERROR(metricInfo[i], COMGETTER(Object)(object.asOutParam())); + CHECK_ERROR(metricInfo[i], COMGETTER(MetricName)(metricName.asOutParam())); + CHECK_ERROR(metricInfo[i], COMGETTER(Period)(&period)); + CHECK_ERROR(metricInfo[i], COMGETTER(Count)(&count)); + CHECK_ERROR(metricInfo[i], COMGETTER(MinimumValue)(&minimum)); + CHECK_ERROR(metricInfo[i], COMGETTER(MaximumValue)(&maximum)); + CHECK_ERROR(metricInfo[i], COMGETTER(Unit)(unit.asOutParam())); + CHECK_ERROR(metricInfo[i], COMGETTER(Description)(description.asOutParam())); + RTPrintf("%-15ls %-40ls %-4ls %10d %10d %10u %10u %ls\n", + getObjectName(object).raw(), metricName.raw(), unit.raw(), + minimum, maximum, period, count, description.raw()); + } + + return RTEXITCODE_SUCCESS; +} + +/** + * Metrics setup + */ +static RTEXITCODE handleMetricsSetup(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + uint32_t period = 1, samples = 1; + bool listMatches = false; + int i; + + for (i = 1; i < argc; i++) + { + if ( !strcmp(argv[i], "--period") + || !strcmp(argv[i], "-period")) + { + if (argc <= i + 1) + return errorArgument("Missing argument to '%s'", argv[i]); + if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period) + || !period) + return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]); + } + else if ( !strcmp(argv[i], "--samples") + || !strcmp(argv[i], "-samples")) + { + if (argc <= i + 1) + return errorArgument("Missing argument to '%s'", argv[i]); + if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples) + || !samples) + return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]); + } + else if ( !strcmp(argv[i], "--list") + || !strcmp(argv[i], "-list")) + listMatches = true; + else + break; /* The rest of params should define the filter */ + } + + rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeIfaceArray<IPerformanceMetric> affectedMetrics; + CHECK_ERROR(performanceCollector, + SetupMetrics(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), period, samples, + ComSafeArrayAsOutParam(affectedMetrics))); + if (FAILED(rc)) + return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */ + + if (listMatches) + listAffectedMetrics(ComSafeArrayAsInParam(affectedMetrics)); + + return RTEXITCODE_SUCCESS; +} + +/** + * metrics query + */ +static RTEXITCODE handleMetricsQuery(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + + rc = parseFilterParameters(argc - 1, &argv[1], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeArray<BSTR> retNames; + com::SafeIfaceArray<IUnknown> retObjects; + com::SafeArray<BSTR> retUnits; + com::SafeArray<ULONG> retScales; + com::SafeArray<ULONG> retSequenceNumbers; + com::SafeArray<ULONG> retIndices; + com::SafeArray<ULONG> retLengths; + com::SafeArray<LONG> retData; + CHECK_ERROR(performanceCollector, QueryMetricsData(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(retNames), + ComSafeArrayAsOutParam(retObjects), + ComSafeArrayAsOutParam(retUnits), + ComSafeArrayAsOutParam(retScales), + ComSafeArrayAsOutParam(retSequenceNumbers), + ComSafeArrayAsOutParam(retIndices), + ComSafeArrayAsOutParam(retLengths), + ComSafeArrayAsOutParam(retData)) ); + + RTPrintf("Object Metric Values\n" + "--------------- ---------------------------------------- --------------------------------------------\n"); + for (unsigned i = 0; i < retNames.size(); i++) + { + Bstr metricUnit(retUnits[i]); + Bstr metricName(retNames[i]); + RTPrintf("%-15ls %-40ls ", getObjectName(retObjects[i]).raw(), metricName.raw()); + const char *separator = ""; + for (unsigned j = 0; j < retLengths[i]; j++) + { + if (retScales[i] == 1) + RTPrintf("%s%d %ls", separator, retData[retIndices[i] + j], metricUnit.raw()); + else + RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[i] + j] / retScales[i], + (retData[retIndices[i] + j] * 100 / retScales[i]) % 100, metricUnit.raw()); + separator = ", "; + } + RTPrintf("\n"); + } + + return RTEXITCODE_SUCCESS; +} + +static void getTimestamp(char *pts, size_t tsSize) +{ + *pts = 0; + AssertReturnVoid(tsSize >= 13); /* 3+3+3+3+1 */ + RTTIMESPEC TimeSpec; + RTTIME Time; + RTTimeExplode(&Time, RTTimeNow(&TimeSpec)); + pts += RTStrFormatNumber(pts, Time.u8Hour, 10, 2, 0, RTSTR_F_ZEROPAD); + *pts++ = ':'; + pts += RTStrFormatNumber(pts, Time.u8Minute, 10, 2, 0, RTSTR_F_ZEROPAD); + *pts++ = ':'; + pts += RTStrFormatNumber(pts, Time.u8Second, 10, 2, 0, RTSTR_F_ZEROPAD); + *pts++ = '.'; + pts += RTStrFormatNumber(pts, Time.u32Nanosecond / 1000000, 10, 3, 0, RTSTR_F_ZEROPAD); + *pts = 0; +} + +/** Used by the handleMetricsCollect loop. */ +static bool volatile g_fKeepGoing = true; + +#ifdef RT_OS_WINDOWS +/** + * Handler routine for catching Ctrl-C, Ctrl-Break and closing of + * the console. + * + * @returns true if handled, false if not handled. + * @param dwCtrlType The type of control signal. + * + * @remarks This is called on a new thread. + */ +static BOOL WINAPI ctrlHandler(DWORD dwCtrlType) +{ + switch (dwCtrlType) + { + /* Ctrl-C or Ctrl-Break or Close */ + case CTRL_C_EVENT: + case CTRL_BREAK_EVENT: + case CTRL_CLOSE_EVENT: + /* Let's shut down gracefully. */ + ASMAtomicWriteBool(&g_fKeepGoing, false); + return TRUE; + } + /* Don't care about the rest -- let it die a horrible death. */ + return FALSE; +} +#endif /* RT_OS_WINDOWS */ + +/** + * collect + */ +static RTEXITCODE handleMetricsCollect(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + uint32_t period = 1, samples = 1; + bool isDetached = false, listMatches = false; + int i; + for (i = 1; i < argc; i++) + { + if ( !strcmp(argv[i], "--period") + || !strcmp(argv[i], "-period")) + { + if (argc <= i + 1) + return errorArgument("Missing argument to '%s'", argv[i]); + if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &period) + || !period) + return errorArgument("Invalid value for 'period' parameter: '%s'", argv[i]); + } + else if ( !strcmp(argv[i], "--samples") + || !strcmp(argv[i], "-samples")) + { + if (argc <= i + 1) + return errorArgument("Missing argument to '%s'", argv[i]); + if ( VINF_SUCCESS != RTStrToUInt32Full(argv[++i], 10, &samples) + || !samples) + return errorArgument("Invalid value for 'samples' parameter: '%s'", argv[i]); + } + else if ( !strcmp(argv[i], "--list") + || !strcmp(argv[i], "-list")) + listMatches = true; + else if ( !strcmp(argv[i], "--detach") + || !strcmp(argv[i], "-detach")) + isDetached = true; + else + break; /* The rest of params should define the filter */ + } + + rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeIfaceArray<IPerformanceMetric> metricInfo; + + CHECK_ERROR(performanceCollector, + GetMetrics(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(metricInfo))); + + std::set<std::pair<ComPtr<IUnknown>,Bstr> > baseMetrics; + ComPtr<IUnknown> objectFiltered; + Bstr metricNameFiltered; + for (i = 0; i < (int)metricInfo.size(); i++) + { + CHECK_ERROR(metricInfo[i], COMGETTER(Object)(objectFiltered.asOutParam())); + CHECK_ERROR(metricInfo[i], COMGETTER(MetricName)(metricNameFiltered.asOutParam())); + Utf8Str baseMetricName(metricNameFiltered); + baseMetrics.insert(std::make_pair(objectFiltered, toBaseName(baseMetricName))); + } + com::SafeArray<BSTR> baseMetricsFiltered(baseMetrics.size()); + com::SafeIfaceArray<IUnknown> objectsFiltered(baseMetrics.size()); + std::set<std::pair<ComPtr<IUnknown>,Bstr> >::iterator it; + i = 0; + for (it = baseMetrics.begin(); it != baseMetrics.end(); ++it) + { + it->first.queryInterfaceTo(&objectsFiltered[i]); + Bstr(it->second).detachTo(&baseMetricsFiltered[i++]); + } + com::SafeIfaceArray<IPerformanceMetric> affectedMetrics; + CHECK_ERROR(performanceCollector, + SetupMetrics(ComSafeArrayAsInParam(baseMetricsFiltered), + ComSafeArrayAsInParam(objectsFiltered), period, samples, + ComSafeArrayAsOutParam(affectedMetrics))); + if (FAILED(rc)) + return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */ + + if (listMatches) + listAffectedMetrics(ComSafeArrayAsInParam(affectedMetrics)); + if (!affectedMetrics.size()) + return RTEXITCODE_FAILURE; + + if (isDetached) + { + RTMsgWarning("The background process holding collected metrics will shutdown\n" + "in few seconds, discarding all collected data and parameters."); + return RTEXITCODE_SUCCESS; + } + +#ifdef RT_OS_WINDOWS + SetConsoleCtrlHandler(ctrlHandler, true); +#endif /* RT_OS_WINDOWS */ + + RTPrintf("Time stamp Object Metric Value\n"); + + while (g_fKeepGoing) + { + RTPrintf("------------ ---------- -------------------- --------------------\n"); + RTThreadSleep(period * 1000); // Sleep for 'period' seconds + char ts[15]; + + getTimestamp(ts, sizeof(ts)); + com::SafeArray<BSTR> retNames; + com::SafeIfaceArray<IUnknown> retObjects; + com::SafeArray<BSTR> retUnits; + com::SafeArray<ULONG> retScales; + com::SafeArray<ULONG> retSequenceNumbers; + com::SafeArray<ULONG> retIndices; + com::SafeArray<ULONG> retLengths; + com::SafeArray<LONG> retData; + CHECK_ERROR(performanceCollector, QueryMetricsData(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(retNames), + ComSafeArrayAsOutParam(retObjects), + ComSafeArrayAsOutParam(retUnits), + ComSafeArrayAsOutParam(retScales), + ComSafeArrayAsOutParam(retSequenceNumbers), + ComSafeArrayAsOutParam(retIndices), + ComSafeArrayAsOutParam(retLengths), + ComSafeArrayAsOutParam(retData)) ); + for (unsigned j = 0; j < retNames.size(); j++) + { + Bstr metricUnit(retUnits[j]); + Bstr metricName(retNames[j]); + RTPrintf("%-12s %-10ls %-20ls ", ts, getObjectName(retObjects[j]).raw(), metricName.raw()); + const char *separator = ""; + for (unsigned k = 0; k < retLengths[j]; k++) + { + if (retScales[j] == 1) + RTPrintf("%s%d %ls", separator, retData[retIndices[j] + k], metricUnit.raw()); + else + RTPrintf("%s%d.%02d%ls", separator, retData[retIndices[j] + k] / retScales[j], + (retData[retIndices[j] + k] * 100 / retScales[j]) % 100, metricUnit.raw()); + separator = ", "; + } + RTPrintf("\n"); + } + RTStrmFlush(g_pStdOut); + } + +#ifdef RT_OS_WINDOWS + SetConsoleCtrlHandler(ctrlHandler, false); +#endif /* RT_OS_WINDOWS */ + + return RTEXITCODE_SUCCESS; +} + +/** + * Enable metrics + */ +static RTEXITCODE handleMetricsEnable(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + bool listMatches = false; + int i; + + for (i = 1; i < argc; i++) + { + if ( !strcmp(argv[i], "--list") + || !strcmp(argv[i], "-list")) + listMatches = true; + else + break; /* The rest of params should define the filter */ + } + + rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeIfaceArray<IPerformanceMetric> affectedMetrics; + CHECK_ERROR(performanceCollector, + EnableMetrics(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(affectedMetrics))); + if (FAILED(rc)) + return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */ + + if (listMatches) + listAffectedMetrics(ComSafeArrayAsInParam(affectedMetrics)); + + return RTEXITCODE_SUCCESS; +} + +/** + * Disable metrics + */ +static RTEXITCODE handleMetricsDisable(int argc, char *argv[], + ComPtr<IVirtualBox> aVirtualBox, + ComPtr<IPerformanceCollector> performanceCollector) +{ + HRESULT rc; + com::SafeArray<BSTR> metrics; + com::SafeIfaceArray<IUnknown> objects; + bool listMatches = false; + int i; + + for (i = 1; i < argc; i++) + { + if ( !strcmp(argv[i], "--list") + || !strcmp(argv[i], "-list")) + listMatches = true; + else + break; /* The rest of params should define the filter */ + } + + rc = parseFilterParameters(argc - i, &argv[i], aVirtualBox, + ComSafeArrayAsOutParam(metrics), + ComSafeArrayAsOutParam(objects)); + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + com::SafeIfaceArray<IPerformanceMetric> affectedMetrics; + CHECK_ERROR(performanceCollector, + DisableMetrics(ComSafeArrayAsInParam(metrics), + ComSafeArrayAsInParam(objects), + ComSafeArrayAsOutParam(affectedMetrics))); + if (FAILED(rc)) + return RTEXITCODE_SYNTAX; /** @todo figure out why we must return 2 here. */ + + if (listMatches) + listAffectedMetrics(ComSafeArrayAsInParam(affectedMetrics)); + + return RTEXITCODE_SUCCESS; +} + + +RTEXITCODE handleMetrics(HandlerArg *a) +{ + /* at least one option: subcommand name */ + if (a->argc < 1) + return errorSyntax(USAGE_METRICS, "Subcommand missing"); + + ComPtr<IPerformanceCollector> performanceCollector; + CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(PerformanceCollector)(performanceCollector.asOutParam()), RTEXITCODE_FAILURE); + + RTEXITCODE rcExit; + if (!strcmp(a->argv[0], "list")) + rcExit = handleMetricsList(a->argc, a->argv, a->virtualBox, performanceCollector); + else if (!strcmp(a->argv[0], "setup")) + rcExit = handleMetricsSetup(a->argc, a->argv, a->virtualBox, performanceCollector); + else if (!strcmp(a->argv[0], "query")) + rcExit = handleMetricsQuery(a->argc, a->argv, a->virtualBox, performanceCollector); + else if (!strcmp(a->argv[0], "collect")) + rcExit = handleMetricsCollect(a->argc, a->argv, a->virtualBox, performanceCollector); + else if (!strcmp(a->argv[0], "enable")) + rcExit = handleMetricsEnable(a->argc, a->argv, a->virtualBox, performanceCollector); + else if (!strcmp(a->argv[0], "disable")) + rcExit = handleMetricsDisable(a->argc, a->argv, a->virtualBox, performanceCollector); + else + return errorSyntax(USAGE_METRICS, "Invalid subcommand '%s'", a->argv[0]); + + return rcExit; +} + +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp new file mode 100644 index 00000000..4d93833d --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageMisc.cpp @@ -0,0 +1,1941 @@ +/* $Id: VBoxManageMisc.cpp $ */ +/** @file + * VBoxManage - VirtualBox's command-line interface. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +# include <VBox/com/com.h> +# include <VBox/com/string.h> +# include <VBox/com/Guid.h> +# include <VBox/com/array.h> +# include <VBox/com/ErrorInfo.h> +# include <VBox/com/errorprint.h> +# include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/asm.h> +#include <iprt/buildconfig.h> +#include <iprt/cidr.h> +#include <iprt/ctype.h> +#include <iprt/dir.h> +#include <iprt/env.h> +#include <iprt/file.h> +#include <iprt/sha.h> +#include <iprt/initterm.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/cpp/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/stdarg.h> +#include <iprt/thread.h> +#include <iprt/uuid.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> +#include <VBox/version.h> +#include <VBox/log.h> + +#include "VBoxManage.h" + +#include <list> + +using namespace com; + + + +RTEXITCODE handleRegisterVM(HandlerArg *a) +{ + HRESULT rc; + + if (a->argc != 1) + return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters"); + + ComPtr<IMachine> machine; + /** @todo Ugly hack to get both the API interpretation of relative paths + * and the client's interpretation of relative paths. Remove after the API + * has been redesigned. */ + rc = a->virtualBox->OpenMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam()); + if (rc == VBOX_E_FILE_ERROR) + { + char szVMFileAbs[RTPATH_MAX] = ""; + int vrc = RTPathAbs(a->argv[0], szVMFileAbs, sizeof(szVMFileAbs)); + if (RT_FAILURE(vrc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc); + CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(szVMFileAbs).raw(), + machine.asOutParam())); + } + else if (FAILED(rc)) + CHECK_ERROR(a->virtualBox, OpenMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (SUCCEEDED(rc)) + { + ASSERT(machine); + CHECK_ERROR(a->virtualBox, RegisterMachine(machine)); + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aUnregisterVMOptions[] = +{ + { "--delete", 'd', RTGETOPT_REQ_NOTHING }, + { "-delete", 'd', RTGETOPT_REQ_NOTHING }, // deprecated +}; + +RTEXITCODE handleUnregisterVM(HandlerArg *a) +{ + HRESULT rc; + const char *VMName = NULL; + bool fDelete = false; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aUnregisterVMOptions, RT_ELEMENTS(g_aUnregisterVMOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'd': // --delete + fDelete = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!VMName) + VMName = ValueUnion.psz; + else + return errorSyntax(USAGE_UNREGISTERVM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_UNREGISTERVM, "Invalid option -%c", c); + return errorSyntax(USAGE_UNREGISTERVM, "Invalid option case %i", c); + } + if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_UNREGISTERVM, "unknown option: %s\n", ValueUnion.psz); + if (ValueUnion.pDef) + return errorSyntax(USAGE_UNREGISTERVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + return errorSyntax(USAGE_UNREGISTERVM, "error: %Rrs", c); + } + } + + /* check for required options */ + if (!VMName) + return errorSyntax(USAGE_UNREGISTERVM, "VM name required"); + + ComPtr<IMachine> machine; + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(VMName).raw(), + machine.asOutParam()), + RTEXITCODE_FAILURE); + SafeIfaceArray<IMedium> aMedia; + CHECK_ERROR_RET(machine, Unregister(CleanupMode_DetachAllReturnHardDisksOnly, + ComSafeArrayAsOutParam(aMedia)), + RTEXITCODE_FAILURE); + if (fDelete) + { + ComPtr<IProgress> pProgress; + CHECK_ERROR_RET(machine, DeleteConfig(ComSafeArrayAsInParam(aMedia), pProgress.asOutParam()), + RTEXITCODE_FAILURE); + + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR_RET(pProgress, ("Machine delete failed"), RTEXITCODE_FAILURE); + } + else + { + /* Note that the IMachine::Unregister method will return the medium + * reference in a sane order, which means that closing will normally + * succeed, unless there is still another machine which uses the + * medium. No harm done if we ignore the error. */ + for (size_t i = 0; i < aMedia.size(); i++) + { + IMedium *pMedium = aMedia[i]; + if (pMedium) + rc = pMedium->Close(); + } + rc = S_OK; + } + return RTEXITCODE_SUCCESS; +} + +static const RTGETOPTDEF g_aCreateVMOptions[] = +{ + { "--name", 'n', RTGETOPT_REQ_STRING }, + { "-name", 'n', RTGETOPT_REQ_STRING }, + { "--groups", 'g', RTGETOPT_REQ_STRING }, + { "--basefolder", 'p', RTGETOPT_REQ_STRING }, + { "-basefolder", 'p', RTGETOPT_REQ_STRING }, + { "--ostype", 'o', RTGETOPT_REQ_STRING }, + { "-ostype", 'o', RTGETOPT_REQ_STRING }, + { "--uuid", 'u', RTGETOPT_REQ_UUID }, + { "-uuid", 'u', RTGETOPT_REQ_UUID }, + { "--register", 'r', RTGETOPT_REQ_NOTHING }, + { "-register", 'r', RTGETOPT_REQ_NOTHING }, + { "--default", 'd', RTGETOPT_REQ_NOTHING }, + { "-default", 'd', RTGETOPT_REQ_NOTHING }, +}; + +RTEXITCODE handleCreateVM(HandlerArg *a) +{ + HRESULT rc; + Bstr bstrBaseFolder; + Bstr bstrName; + Bstr bstrOsTypeId; + Bstr bstrUuid; + bool fRegister = false; + bool fDefault = false; + /* TBD. Now not used */ + Bstr bstrDefaultFlags; + com::SafeArray<BSTR> groups; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aCreateVMOptions, RT_ELEMENTS(g_aCreateVMOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'n': // --name + bstrName = ValueUnion.psz; + break; + + case 'g': // --groups + parseGroups(ValueUnion.psz, &groups); + break; + + case 'p': // --basefolder + bstrBaseFolder = ValueUnion.psz; + break; + + case 'o': // --ostype + bstrOsTypeId = ValueUnion.psz; + break; + + case 'u': // --uuid + bstrUuid = Guid(ValueUnion.Uuid).toUtf16().raw(); + break; + + case 'r': // --register + fRegister = true; + break; + + case 'd': // --default + fDefault = true; + break; + + default: + return errorGetOpt(USAGE_CREATEVM, c, &ValueUnion); + } + } + + /* check for required options */ + if (bstrName.isEmpty()) + return errorSyntax(USAGE_CREATEVM, "Parameter --name is required"); + + do + { + Bstr createFlags; + if (!bstrUuid.isEmpty()) + createFlags = BstrFmt("UUID=%ls", bstrUuid.raw()); + Bstr bstrPrimaryGroup; + if (groups.size()) + bstrPrimaryGroup = groups[0]; + Bstr bstrSettingsFile; + CHECK_ERROR_BREAK(a->virtualBox, + ComposeMachineFilename(bstrName.raw(), + bstrPrimaryGroup.raw(), + createFlags.raw(), + bstrBaseFolder.raw(), + bstrSettingsFile.asOutParam())); + ComPtr<IMachine> machine; + CHECK_ERROR_BREAK(a->virtualBox, + CreateMachine(bstrSettingsFile.raw(), + bstrName.raw(), + ComSafeArrayAsInParam(groups), + bstrOsTypeId.raw(), + createFlags.raw(), + machine.asOutParam())); + + CHECK_ERROR_BREAK(machine, SaveSettings()); + if (fRegister) + { + CHECK_ERROR_BREAK(a->virtualBox, RegisterMachine(machine)); + } + if (fDefault) + { + /* ApplyDefaults assumes the machine is already registered */ + CHECK_ERROR_BREAK(machine, ApplyDefaults(bstrDefaultFlags.raw())); + CHECK_ERROR_BREAK(machine, SaveSettings()); + } + Bstr uuid; + CHECK_ERROR_BREAK(machine, COMGETTER(Id)(uuid.asOutParam())); + Bstr settingsFile; + CHECK_ERROR_BREAK(machine, COMGETTER(SettingsFilePath)(settingsFile.asOutParam())); + RTPrintf("Virtual machine '%ls' is created%s.\n" + "UUID: %s\n" + "Settings file: '%ls'\n", + bstrName.raw(), fRegister ? " and registered" : "", + Utf8Str(uuid).c_str(), settingsFile.raw()); + } + while (0); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static const RTGETOPTDEF g_aMoveVMOptions[] = +{ + { "--type", 't', RTGETOPT_REQ_STRING }, + { "--folder", 'f', RTGETOPT_REQ_STRING }, +}; + +RTEXITCODE handleMoveVM(HandlerArg *a) +{ + HRESULT rc; + const char *pszSrcName = NULL; + const char *pszTargetFolder = NULL; + const char *pszType = NULL; + + int c; + int vrc = VINF_SUCCESS; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aMoveVMOptions, RT_ELEMENTS(g_aMoveVMOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 't': // --type + pszType = ValueUnion.psz; + break; + + case 'f': // --target folder + + char szPath[RTPATH_MAX]; + pszTargetFolder = ValueUnion.psz; + + vrc = RTPathAbs(pszTargetFolder, szPath, sizeof(szPath)); + if (RT_FAILURE(vrc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", pszTargetFolder, vrc); + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszSrcName) + pszSrcName = ValueUnion.psz; + else + return errorSyntax(USAGE_MOVEVM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + return errorGetOpt(USAGE_MOVEVM, c, &ValueUnion); + } + } + + + if (!pszType) + { + pszType = "basic"; + } + + /* Check for required options */ + if (!pszSrcName) + return errorSyntax(USAGE_MOVEVM, "VM name required"); + + /* Get the machine object */ + ComPtr<IMachine> srcMachine; + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(pszSrcName).raw(), + srcMachine.asOutParam()), + RTEXITCODE_FAILURE); + + if (srcMachine) + { + /* Start the moving */ + ComPtr<IProgress> progress; + + /* we have to open a session for this task */ + CHECK_ERROR_RET(srcMachine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE); + ComPtr<IMachine> sessionMachine; + + CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(sessionMachine, MoveTo(Bstr(pszTargetFolder).raw(), + Bstr(pszType).raw(), + progress.asOutParam()), RTEXITCODE_FAILURE); + rc = showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Move VM failed"), RTEXITCODE_FAILURE); + + sessionMachine.setNull(); + CHECK_ERROR_RET(a->session, UnlockMachine(), RTEXITCODE_FAILURE); + +// do +// { +// /* we have to open a session for this task */ +// CHECK_ERROR_BREAK(srcMachine, LockMachine(a->session, LockType_Write)); +// ComPtr<IMachine> sessionMachine; +// do +// { +// CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam())); +// CHECK_ERROR_BREAK(sessionMachine, MoveTo(Bstr(pszTargetFolder).raw(), +// Bstr(pszType).raw(), +// progress.asOutParam())); +// rc = showProgress(progress); +// CHECK_PROGRESS_ERROR_RET(progress, ("Move VM failed"), RTEXITCODE_FAILURE); +//// CHECK_ERROR_BREAK(sessionMachine, SaveSettings()); +// } while (0); +// +// sessionMachine.setNull(); +// CHECK_ERROR_BREAK(a->session, UnlockMachine()); +// } while (0); + RTPrintf("Machine has been successfully moved into %s\n", pszTargetFolder); + } + + return RTEXITCODE_SUCCESS; +} + +static const RTGETOPTDEF g_aCloneVMOptions[] = +{ + { "--snapshot", 's', RTGETOPT_REQ_STRING }, + { "--name", 'n', RTGETOPT_REQ_STRING }, + { "--groups", 'g', RTGETOPT_REQ_STRING }, + { "--mode", 'm', RTGETOPT_REQ_STRING }, + { "--options", 'o', RTGETOPT_REQ_STRING }, + { "--register", 'r', RTGETOPT_REQ_NOTHING }, + { "--basefolder", 'p', RTGETOPT_REQ_STRING }, + { "--uuid", 'u', RTGETOPT_REQ_UUID }, +}; + +static int parseCloneMode(const char *psz, CloneMode_T *pMode) +{ + if (!RTStrICmp(psz, "machine")) + *pMode = CloneMode_MachineState; + else if (!RTStrICmp(psz, "machineandchildren")) + *pMode = CloneMode_MachineAndChildStates; + else if (!RTStrICmp(psz, "all")) + *pMode = CloneMode_AllStates; + else + return VERR_PARSE_ERROR; + + return VINF_SUCCESS; +} + +static int parseCloneOptions(const char *psz, com::SafeArray<CloneOptions_T> *options) +{ + int rc = VINF_SUCCESS; + while (psz && *psz && RT_SUCCESS(rc)) + { + size_t len; + const char *pszComma = strchr(psz, ','); + if (pszComma) + len = pszComma - psz; + else + len = strlen(psz); + if (len > 0) + { + if (!RTStrNICmp(psz, "KeepAllMACs", len)) + options->push_back(CloneOptions_KeepAllMACs); + else if (!RTStrNICmp(psz, "KeepNATMACs", len)) + options->push_back(CloneOptions_KeepNATMACs); + else if (!RTStrNICmp(psz, "KeepDiskNames", len)) + options->push_back(CloneOptions_KeepDiskNames); + else if ( !RTStrNICmp(psz, "Link", len) + || !RTStrNICmp(psz, "Linked", len)) + options->push_back(CloneOptions_Link); + else if ( !RTStrNICmp(psz, "KeepHwUUIDs", len) + || !RTStrNICmp(psz, "KeepHwUUID", len)) + options->push_back(CloneOptions_KeepHwUUIDs); + else + rc = VERR_PARSE_ERROR; + } + if (pszComma) + psz += len + 1; + else + psz += len; + } + + return rc; +} + +RTEXITCODE handleCloneVM(HandlerArg *a) +{ + HRESULT rc; + const char *pszSrcName = NULL; + const char *pszSnapshotName = NULL; + CloneMode_T mode = CloneMode_MachineState; + com::SafeArray<CloneOptions_T> options; + const char *pszTrgName = NULL; + const char *pszTrgBaseFolder = NULL; + bool fRegister = false; + Bstr bstrUuid; + com::SafeArray<BSTR> groups; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, g_aCloneVMOptions, RT_ELEMENTS(g_aCloneVMOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 's': // --snapshot + pszSnapshotName = ValueUnion.psz; + break; + + case 'n': // --name + pszTrgName = ValueUnion.psz; + break; + + case 'g': // --groups + parseGroups(ValueUnion.psz, &groups); + break; + + case 'p': // --basefolder + pszTrgBaseFolder = ValueUnion.psz; + break; + + case 'm': // --mode + if (RT_FAILURE(parseCloneMode(ValueUnion.psz, &mode))) + return errorArgument("Invalid clone mode '%s'\n", ValueUnion.psz); + break; + + case 'o': // --options + if (RT_FAILURE(parseCloneOptions(ValueUnion.psz, &options))) + return errorArgument("Invalid clone options '%s'\n", ValueUnion.psz); + break; + + case 'u': // --uuid + bstrUuid = Guid(ValueUnion.Uuid).toUtf16().raw(); + break; + + case 'r': // --register + fRegister = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (!pszSrcName) + pszSrcName = ValueUnion.psz; + else + return errorSyntax(USAGE_CLONEVM, "Invalid parameter '%s'", ValueUnion.psz); + break; + + default: + return errorGetOpt(USAGE_CLONEVM, c, &ValueUnion); + } + } + + /* Check for required options */ + if (!pszSrcName) + return errorSyntax(USAGE_CLONEVM, "VM name required"); + + /* Get the machine object */ + ComPtr<IMachine> srcMachine; + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(pszSrcName).raw(), + srcMachine.asOutParam()), + RTEXITCODE_FAILURE); + + /* If a snapshot name/uuid was given, get the particular machine of this + * snapshot. */ + if (pszSnapshotName) + { + ComPtr<ISnapshot> srcSnapshot; + CHECK_ERROR_RET(srcMachine, FindSnapshot(Bstr(pszSnapshotName).raw(), + srcSnapshot.asOutParam()), + RTEXITCODE_FAILURE); + CHECK_ERROR_RET(srcSnapshot, COMGETTER(Machine)(srcMachine.asOutParam()), + RTEXITCODE_FAILURE); + } + + /* Default name necessary? */ + if (!pszTrgName) + pszTrgName = RTStrAPrintf2("%s Clone", pszSrcName); + + Bstr createFlags; + if (!bstrUuid.isEmpty()) + createFlags = BstrFmt("UUID=%ls", bstrUuid.raw()); + Bstr bstrPrimaryGroup; + if (groups.size()) + bstrPrimaryGroup = groups[0]; + Bstr bstrSettingsFile; + CHECK_ERROR_RET(a->virtualBox, + ComposeMachineFilename(Bstr(pszTrgName).raw(), + bstrPrimaryGroup.raw(), + createFlags.raw(), + Bstr(pszTrgBaseFolder).raw(), + bstrSettingsFile.asOutParam()), + RTEXITCODE_FAILURE); + + ComPtr<IMachine> trgMachine; + CHECK_ERROR_RET(a->virtualBox, CreateMachine(bstrSettingsFile.raw(), + Bstr(pszTrgName).raw(), + ComSafeArrayAsInParam(groups), + NULL, + createFlags.raw(), + trgMachine.asOutParam()), + RTEXITCODE_FAILURE); + + /* Start the cloning */ + ComPtr<IProgress> progress; + CHECK_ERROR_RET(srcMachine, CloneTo(trgMachine, + mode, + ComSafeArrayAsInParam(options), + progress.asOutParam()), + RTEXITCODE_FAILURE); + rc = showProgress(progress); + CHECK_PROGRESS_ERROR_RET(progress, ("Clone VM failed"), RTEXITCODE_FAILURE); + + if (fRegister) + CHECK_ERROR_RET(a->virtualBox, RegisterMachine(trgMachine), RTEXITCODE_FAILURE); + + Bstr bstrNewName; + CHECK_ERROR_RET(trgMachine, COMGETTER(Name)(bstrNewName.asOutParam()), RTEXITCODE_FAILURE); + RTPrintf("Machine has been successfully cloned as \"%ls\"\n", bstrNewName.raw()); + + return RTEXITCODE_SUCCESS; +} + +RTEXITCODE handleStartVM(HandlerArg *a) +{ + HRESULT rc = S_OK; + std::list<const char *> VMs; + Bstr sessionType; + Utf8Str strEnv; + +#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) + /* make sure the VM process will by default start on the same display as VBoxManage */ + { + const char *pszDisplay = RTEnvGet("DISPLAY"); + if (pszDisplay) + strEnv = Utf8StrFmt("DISPLAY=%s\n", pszDisplay); + const char *pszXAuth = RTEnvGet("XAUTHORITY"); + if (pszXAuth) + strEnv.append(Utf8StrFmt("XAUTHORITY=%s\n", pszXAuth)); + } +#endif + + static const RTGETOPTDEF s_aStartVMOptions[] = + { + { "--type", 't', RTGETOPT_REQ_STRING }, + { "-type", 't', RTGETOPT_REQ_STRING }, // deprecated + { "--putenv", 'E', RTGETOPT_REQ_STRING }, + }; + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + // start at 0 because main() has hacked both the argc and argv given to us + RTGetOptInit(&GetState, a->argc, a->argv, s_aStartVMOptions, RT_ELEMENTS(s_aStartVMOptions), + 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 't': // --type + if (!RTStrICmp(ValueUnion.psz, "gui")) + { + sessionType = "gui"; + } +#ifdef VBOX_WITH_VBOXSDL + else if (!RTStrICmp(ValueUnion.psz, "sdl")) + { + sessionType = "sdl"; + } +#endif +#ifdef VBOX_WITH_HEADLESS + else if (!RTStrICmp(ValueUnion.psz, "capture")) + { + sessionType = "capture"; + } + else if (!RTStrICmp(ValueUnion.psz, "headless")) + { + sessionType = "headless"; + } +#endif + else + sessionType = ValueUnion.psz; + break; + + case 'E': // --putenv + if (!RTStrStr(ValueUnion.psz, "\n")) + strEnv.append(Utf8StrFmt("%s\n", ValueUnion.psz)); + else + return errorSyntax(USAGE_STARTVM, "Parameter to option --putenv must not contain any newline character"); + break; + + case VINF_GETOPT_NOT_OPTION: + VMs.push_back(ValueUnion.psz); + break; + + default: + if (c > 0) + { + if (RT_C_IS_PRINT(c)) + return errorSyntax(USAGE_STARTVM, "Invalid option -%c", c); + else + return errorSyntax(USAGE_STARTVM, "Invalid option case %i", c); + } + else if (c == VERR_GETOPT_UNKNOWN_OPTION) + return errorSyntax(USAGE_STARTVM, "unknown option: %s\n", ValueUnion.psz); + else if (ValueUnion.pDef) + return errorSyntax(USAGE_STARTVM, "%s: %Rrs", ValueUnion.pDef->pszLong, c); + else + return errorSyntax(USAGE_STARTVM, "error: %Rrs", c); + } + } + + /* check for required options */ + if (VMs.empty()) + return errorSyntax(USAGE_STARTVM, "at least one VM name or uuid required"); + + for (std::list<const char *>::const_iterator it = VMs.begin(); + it != VMs.end(); + ++it) + { + HRESULT rc2 = rc; + const char *pszVM = *it; + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(pszVM).raw(), + machine.asOutParam())); + if (machine) + { + ComPtr<IProgress> progress; + CHECK_ERROR(machine, LaunchVMProcess(a->session, sessionType.raw(), + Bstr(strEnv).raw(), progress.asOutParam())); + if (SUCCEEDED(rc) && !progress.isNull()) + { + RTPrintf("Waiting for VM \"%s\" to power on...\n", pszVM); + CHECK_ERROR(progress, WaitForCompletion(-1)); + if (SUCCEEDED(rc)) + { + BOOL completed = true; + CHECK_ERROR(progress, COMGETTER(Completed)(&completed)); + if (SUCCEEDED(rc)) + { + ASSERT(completed); + + LONG iRc; + CHECK_ERROR(progress, COMGETTER(ResultCode)(&iRc)); + if (SUCCEEDED(rc)) + { + if (SUCCEEDED(iRc)) + RTPrintf("VM \"%s\" has been successfully started.\n", pszVM); + else + { + ProgressErrorInfo info(progress); + com::GluePrintErrorInfo(info); + } + rc = iRc; + } + } + } + } + } + + /* it's important to always close sessions */ + a->session->UnlockMachine(); + + /* make sure that we remember the failed state */ + if (FAILED(rc2)) + rc = rc2; + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleDiscardState(HandlerArg *a) +{ + HRESULT rc; + + if (a->argc != 1) + return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters"); + + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + do + { + /* we have to open a session for this task */ + CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write)); + do + { + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam())); + CHECK_ERROR_BREAK(sessionMachine, DiscardSavedState(true /* fDeleteFile */)); + } while (0); + CHECK_ERROR_BREAK(a->session, UnlockMachine()); + } while (0); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleAdoptState(HandlerArg *a) +{ + HRESULT rc; + + if (a->argc != 2) + return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters"); + + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + char szStateFileAbs[RTPATH_MAX] = ""; + int vrc = RTPathAbs(a->argv[1], szStateFileAbs, sizeof(szStateFileAbs)); + if (RT_FAILURE(vrc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Cannot convert filename \"%s\" to absolute path: %Rrc", a->argv[0], vrc); + + do + { + /* we have to open a session for this task */ + CHECK_ERROR_BREAK(machine, LockMachine(a->session, LockType_Write)); + do + { + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam())); + CHECK_ERROR_BREAK(sessionMachine, AdoptSavedState(Bstr(szStateFileAbs).raw())); + } while (0); + CHECK_ERROR_BREAK(a->session, UnlockMachine()); + } while (0); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleGetExtraData(HandlerArg *a) +{ + HRESULT rc = S_OK; + + if (a->argc > 2 || a->argc < 1) + return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters"); + + /* global data? */ + if (!strcmp(a->argv[0], "global")) + { + /* enumeration? */ + if (a->argc < 2 || !strcmp(a->argv[1], "enumerate")) + { + SafeArray<BSTR> aKeys; + CHECK_ERROR(a->virtualBox, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys))); + + for (size_t i = 0; + i < aKeys.size(); + ++i) + { + Bstr bstrKey(aKeys[i]); + Bstr bstrValue; + CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey.raw(), + bstrValue.asOutParam())); + + RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw()); + } + } + else + { + Bstr value; + CHECK_ERROR(a->virtualBox, GetExtraData(Bstr(a->argv[1]).raw(), + value.asOutParam())); + if (!value.isEmpty()) + RTPrintf("Value: %ls\n", value.raw()); + else + RTPrintf("No value set!\n"); + } + } + else + { + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* enumeration? */ + if (a->argc < 2 || !strcmp(a->argv[1], "enumerate")) + { + SafeArray<BSTR> aKeys; + CHECK_ERROR(machine, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys))); + + for (size_t i = 0; + i < aKeys.size(); + ++i) + { + Bstr bstrKey(aKeys[i]); + Bstr bstrValue; + CHECK_ERROR(machine, GetExtraData(bstrKey.raw(), + bstrValue.asOutParam())); + + RTPrintf("Key: %ls, Value: %ls\n", bstrKey.raw(), bstrValue.raw()); + } + } + else + { + Bstr value; + CHECK_ERROR(machine, GetExtraData(Bstr(a->argv[1]).raw(), + value.asOutParam())); + if (!value.isEmpty()) + RTPrintf("Value: %ls\n", value.raw()); + else + RTPrintf("No value set!\n"); + } + } + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleSetExtraData(HandlerArg *a) +{ + HRESULT rc = S_OK; + + if (a->argc < 2) + return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters"); + + /* global data? */ + if (!strcmp(a->argv[0], "global")) + { + /** @todo passing NULL is deprecated */ + if (a->argc < 3) + CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(), + NULL)); + else if (a->argc == 3) + CHECK_ERROR(a->virtualBox, SetExtraData(Bstr(a->argv[1]).raw(), + Bstr(a->argv[2]).raw())); + else + return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters"); + } + else + { + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam())); + if (machine) + { + /* open an existing session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + /* get the session machine */ + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE); + /** @todo passing NULL is deprecated */ + if (a->argc < 3) + CHECK_ERROR(sessionMachine, SetExtraData(Bstr(a->argv[1]).raw(), + NULL)); + else if (a->argc == 3) + CHECK_ERROR(sessionMachine, SetExtraData(Bstr(a->argv[1]).raw(), + Bstr(a->argv[2]).raw())); + else + return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters"); + } + } + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleSetProperty(HandlerArg *a) +{ + HRESULT rc; + + /* there must be two arguments: property name and value */ + if (a->argc != 2) + return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters"); + + ComPtr<ISystemProperties> systemProperties; + a->virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam()); + + if (!strcmp(a->argv[0], "machinefolder")) + { + /* reset to default? */ + if (!strcmp(a->argv[1], "default")) + CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(NULL)); + else + CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(a->argv[1]).raw())); + } + else if (!strcmp(a->argv[0], "hwvirtexclusive")) + { + bool fHwVirtExclusive; + + if (!strcmp(a->argv[1], "on")) + fHwVirtExclusive = true; + else if (!strcmp(a->argv[1], "off")) + fHwVirtExclusive = false; + else + return errorArgument("Invalid hwvirtexclusive argument '%s'", a->argv[1]); + CHECK_ERROR(systemProperties, COMSETTER(ExclusiveHwVirt)(fHwVirtExclusive)); + } + else if ( !strcmp(a->argv[0], "vrdeauthlibrary") + || !strcmp(a->argv[0], "vrdpauthlibrary")) + { + if (!strcmp(a->argv[0], "vrdpauthlibrary")) + RTStrmPrintf(g_pStdErr, "Warning: 'vrdpauthlibrary' is deprecated. Use 'vrdeauthlibrary'.\n"); + + /* reset to default? */ + if (!strcmp(a->argv[1], "default")) + CHECK_ERROR(systemProperties, COMSETTER(VRDEAuthLibrary)(NULL)); + else + CHECK_ERROR(systemProperties, COMSETTER(VRDEAuthLibrary)(Bstr(a->argv[1]).raw())); + } + else if (!strcmp(a->argv[0], "websrvauthlibrary")) + { + /* reset to default? */ + if (!strcmp(a->argv[1], "default")) + CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(NULL)); + else + CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(a->argv[1]).raw())); + } + else if (!strcmp(a->argv[0], "vrdeextpack")) + { + /* disable? */ + if (!strcmp(a->argv[1], "null")) + CHECK_ERROR(systemProperties, COMSETTER(DefaultVRDEExtPack)(NULL)); + else + CHECK_ERROR(systemProperties, COMSETTER(DefaultVRDEExtPack)(Bstr(a->argv[1]).raw())); + } + else if (!strcmp(a->argv[0], "loghistorycount")) + { + uint32_t uVal; + int vrc; + vrc = RTStrToUInt32Ex(a->argv[1], NULL, 0, &uVal); + if (vrc != VINF_SUCCESS) + return errorArgument("Error parsing Log history count '%s'", a->argv[1]); + CHECK_ERROR(systemProperties, COMSETTER(LogHistoryCount)(uVal)); + } + else if (!strcmp(a->argv[0], "autostartdbpath")) + { + /* disable? */ + if (!strcmp(a->argv[1], "null")) + CHECK_ERROR(systemProperties, COMSETTER(AutostartDatabasePath)(NULL)); + else + CHECK_ERROR(systemProperties, COMSETTER(AutostartDatabasePath)(Bstr(a->argv[1]).raw())); + } + else if (!strcmp(a->argv[0], "defaultfrontend")) + { + Bstr bstrDefaultFrontend(a->argv[1]); + if (!strcmp(a->argv[1], "default")) + bstrDefaultFrontend.setNull(); + CHECK_ERROR(systemProperties, COMSETTER(DefaultFrontend)(bstrDefaultFrontend.raw())); + } + else if (!strcmp(a->argv[0], "logginglevel")) + { + Bstr bstrLoggingLevel(a->argv[1]); + if (!strcmp(a->argv[1], "default")) + bstrLoggingLevel.setNull(); + CHECK_ERROR(systemProperties, COMSETTER(LoggingLevel)(bstrLoggingLevel.raw())); + } + else if (!strcmp(a->argv[0], "proxymode")) + { + ProxyMode_T enmProxyMode; + if (!RTStrICmpAscii(a->argv[1], "system")) + enmProxyMode = ProxyMode_System; + else if (!RTStrICmpAscii(a->argv[1], "noproxy")) + enmProxyMode = ProxyMode_NoProxy; + else if (!RTStrICmpAscii(a->argv[1], "manual")) + enmProxyMode = ProxyMode_Manual; + else + return errorArgument("Unknown proxy mode: '%s'", a->argv[1]); + CHECK_ERROR(systemProperties, COMSETTER(ProxyMode)(enmProxyMode)); + } + else if (!strcmp(a->argv[0], "proxyurl")) + { + Bstr bstrProxyUrl(a->argv[1]); + CHECK_ERROR(systemProperties, COMSETTER(ProxyURL)(bstrProxyUrl.raw())); + } + else + return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", a->argv[0]); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleSharedFolder(HandlerArg *a) +{ + HRESULT rc; + + /* we need at least a command and target */ + if (a->argc < 2) + return errorSyntax(USAGE_SHAREDFOLDER, "Not enough parameters"); + + const char *pszMachineName = a->argv[1]; + ComPtr<IMachine> machine; + CHECK_ERROR(a->virtualBox, FindMachine(Bstr(pszMachineName).raw(), machine.asOutParam())); + if (!machine) + return RTEXITCODE_FAILURE; + + if (!strcmp(a->argv[0], "add")) + { + /* we need at least four more parameters */ + if (a->argc < 5) + return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Not enough parameters"); + + char *name = NULL; + char *hostpath = NULL; + bool fTransient = false; + bool fWritable = true; + bool fAutoMount = false; + const char *pszAutoMountPoint = ""; + + for (int i = 2; i < a->argc; i++) + { + if ( !strcmp(a->argv[i], "--name") + || !strcmp(a->argv[i], "-name")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + name = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--hostpath") + || !strcmp(a->argv[i], "-hostpath")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + hostpath = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--readonly") + || !strcmp(a->argv[i], "-readonly")) + { + fWritable = false; + } + else if ( !strcmp(a->argv[i], "--transient") + || !strcmp(a->argv[i], "-transient")) + { + fTransient = true; + } + else if ( !strcmp(a->argv[i], "--automount") + || !strcmp(a->argv[i], "-automount")) + { + fAutoMount = true; + } + else if (!strcmp(a->argv[i], "--auto-mount-point")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + pszAutoMountPoint = a->argv[i]; + } + else + return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str()); + } + + if (NULL != strstr(name, " ")) + return errorSyntax(USAGE_SHAREDFOLDER_ADD, "No spaces allowed in parameter '-name'!"); + + /* required arguments */ + if (!name || !hostpath) + { + return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Parameters --name and --hostpath are required"); + } + + if (fTransient) + { + ComPtr<IConsole> console; + + /* open an existing session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + + /* get the session machine */ + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE); + + /* get the session console */ + CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), RTEXITCODE_FAILURE); + if (console.isNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, + "Machine '%s' is not currently running.\n", pszMachineName); + + CHECK_ERROR(console, CreateSharedFolder(Bstr(name).raw(), Bstr(hostpath).raw(), + fWritable, fAutoMount, Bstr(pszAutoMountPoint).raw())); + a->session->UnlockMachine(); + } + else + { + /* open a session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + ComPtr<IMachine> sessionMachine; + a->session->COMGETTER(Machine)(sessionMachine.asOutParam()); + + CHECK_ERROR(sessionMachine, CreateSharedFolder(Bstr(name).raw(), Bstr(hostpath).raw(), + fWritable, fAutoMount, Bstr(pszAutoMountPoint).raw())); + if (SUCCEEDED(rc)) + CHECK_ERROR(sessionMachine, SaveSettings()); + + a->session->UnlockMachine(); + } + } + else if (!strcmp(a->argv[0], "remove")) + { + /* we need at least two more parameters */ + if (a->argc < 3) + return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Not enough parameters"); + + char *name = NULL; + bool fTransient = false; + + for (int i = 2; i < a->argc; i++) + { + if ( !strcmp(a->argv[i], "--name") + || !strcmp(a->argv[i], "-name")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + name = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--transient") + || !strcmp(a->argv[i], "-transient")) + { + fTransient = true; + } + else + return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str()); + } + + /* required arguments */ + if (!name) + return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Parameter --name is required"); + + if (fTransient) + { + /* open an existing session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + /* get the session machine */ + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE); + /* get the session console */ + ComPtr<IConsole> console; + CHECK_ERROR_RET(a->session, COMGETTER(Console)(console.asOutParam()), RTEXITCODE_FAILURE); + if (console.isNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, + "Machine '%s' is not currently running.\n", pszMachineName); + + CHECK_ERROR(console, RemoveSharedFolder(Bstr(name).raw())); + + a->session->UnlockMachine(); + } + else + { + /* open a session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + ComPtr<IMachine> sessionMachine; + a->session->COMGETTER(Machine)(sessionMachine.asOutParam()); + + CHECK_ERROR(sessionMachine, RemoveSharedFolder(Bstr(name).raw())); + + /* commit and close the session */ + CHECK_ERROR(sessionMachine, SaveSettings()); + a->session->UnlockMachine(); + } + } + else + return errorSyntax(USAGE_SHAREDFOLDER, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str()); + + return RTEXITCODE_SUCCESS; +} + +RTEXITCODE handleExtPack(HandlerArg *a) +{ + if (a->argc < 1) + return errorNoSubcommand(); + + ComObjPtr<IExtPackManager> ptrExtPackMgr; + CHECK_ERROR2I_RET(a->virtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), RTEXITCODE_FAILURE); + + RTGETOPTSTATE GetState; + RTGETOPTUNION ValueUnion; + int ch; + HRESULT hrc = S_OK; + + if (!strcmp(a->argv[0], "install")) + { + setCurrentSubcommand(HELP_SCOPE_EXTPACK_INSTALL); + const char *pszName = NULL; + bool fReplace = false; + + static const RTGETOPTDEF s_aInstallOptions[] = + { + { "--replace", 'r', RTGETOPT_REQ_NOTHING }, + { "--accept-license", 'a', RTGETOPT_REQ_STRING }, + }; + + RTCList<RTCString> lstLicenseHashes; + RTGetOptInit(&GetState, a->argc, a->argv, s_aInstallOptions, RT_ELEMENTS(s_aInstallOptions), 1, 0 /*fFlags*/); + while ((ch = RTGetOpt(&GetState, &ValueUnion))) + { + switch (ch) + { + case 'r': + fReplace = true; + break; + + case 'a': + lstLicenseHashes.append(ValueUnion.psz); + lstLicenseHashes[lstLicenseHashes.size() - 1].toLower(); + break; + + case VINF_GETOPT_NOT_OPTION: + if (pszName) + return errorSyntax("Too many extension pack names given to \"extpack uninstall\""); + pszName = ValueUnion.psz; + break; + + default: + return errorGetOpt(ch, &ValueUnion); + } + } + if (!pszName) + return errorSyntax("No extension pack name was given to \"extpack install\""); + + char szPath[RTPATH_MAX]; + int vrc = RTPathAbs(pszName, szPath, sizeof(szPath)); + if (RT_FAILURE(vrc)) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs(%s,,) failed with rc=%Rrc", pszName, vrc); + + Bstr bstrTarball(szPath); + Bstr bstrName; + ComPtr<IExtPackFile> ptrExtPackFile; + CHECK_ERROR2I_RET(ptrExtPackMgr, OpenExtPackFile(bstrTarball.raw(), ptrExtPackFile.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR2I_RET(ptrExtPackFile, COMGETTER(Name)(bstrName.asOutParam()), RTEXITCODE_FAILURE); + BOOL fShowLicense = true; + CHECK_ERROR2I_RET(ptrExtPackFile, COMGETTER(ShowLicense)(&fShowLicense), RTEXITCODE_FAILURE); + if (fShowLicense) + { + Bstr bstrLicense; + CHECK_ERROR2I_RET(ptrExtPackFile, + QueryLicense(Bstr("").raw() /* PreferredLocale */, + Bstr("").raw() /* PreferredLanguage */, + Bstr("txt").raw() /* Format */, + bstrLicense.asOutParam()), RTEXITCODE_FAILURE); + Utf8Str strLicense(bstrLicense); + uint8_t abHash[RTSHA256_HASH_SIZE]; + char szDigest[RTSHA256_DIGEST_LEN + 1]; + RTSha256(strLicense.c_str(), strLicense.length(), abHash); + vrc = RTSha256ToString(abHash, szDigest, sizeof(szDigest)); + AssertRCStmt(vrc, szDigest[0] = '\0'); + if (lstLicenseHashes.contains(szDigest)) + RTPrintf("License accepted.\n"); + else + { + RTPrintf("%s\n", strLicense.c_str()); + RTPrintf("Do you agree to these license terms and conditions (y/n)? " ); + ch = RTStrmGetCh(g_pStdIn); + RTPrintf("\n"); + if (ch != 'y' && ch != 'Y') + { + RTPrintf("Installation of \"%ls\" aborted.\n", bstrName.raw()); + return RTEXITCODE_FAILURE; + } + if (szDigest[0]) + RTPrintf("License accepted. For batch installaltion add\n" + "--accept-license=%s\n" + "to the VBoxManage command line.\n\n", szDigest); + } + } + ComPtr<IProgress> ptrProgress; + CHECK_ERROR2I_RET(ptrExtPackFile, Install(fReplace, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE); + hrc = showProgress(ptrProgress); + CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to install \"%s\"", szPath), RTEXITCODE_FAILURE); + + RTPrintf("Successfully installed \"%ls\".\n", bstrName.raw()); + } + else if (!strcmp(a->argv[0], "uninstall")) + { + setCurrentSubcommand(HELP_SCOPE_EXTPACK_UNINSTALL); + const char *pszName = NULL; + bool fForced = false; + + static const RTGETOPTDEF s_aUninstallOptions[] = + { + { "--force", 'f', RTGETOPT_REQ_NOTHING }, + }; + + RTGetOptInit(&GetState, a->argc, a->argv, s_aUninstallOptions, RT_ELEMENTS(s_aUninstallOptions), 1, 0); + while ((ch = RTGetOpt(&GetState, &ValueUnion))) + { + switch (ch) + { + case 'f': + fForced = true; + break; + + case VINF_GETOPT_NOT_OPTION: + if (pszName) + return errorSyntax("Too many extension pack names given to \"extpack uninstall\""); + pszName = ValueUnion.psz; + break; + + default: + return errorGetOpt(ch, &ValueUnion); + } + } + if (!pszName) + return errorSyntax("No extension pack name was given to \"extpack uninstall\""); + + Bstr bstrName(pszName); + ComPtr<IProgress> ptrProgress; + CHECK_ERROR2I_RET(ptrExtPackMgr, Uninstall(bstrName.raw(), fForced, NULL, ptrProgress.asOutParam()), RTEXITCODE_FAILURE); + hrc = showProgress(ptrProgress); + CHECK_PROGRESS_ERROR_RET(ptrProgress, ("Failed to uninstall \"%s\"", pszName), RTEXITCODE_FAILURE); + + RTPrintf("Successfully uninstalled \"%s\".\n", pszName); + } + else if (!strcmp(a->argv[0], "cleanup")) + { + setCurrentSubcommand(HELP_SCOPE_EXTPACK_CLEANUP); + if (a->argc > 1) + return errorTooManyParameters(&a->argv[1]); + CHECK_ERROR2I_RET(ptrExtPackMgr, Cleanup(), RTEXITCODE_FAILURE); + RTPrintf("Successfully performed extension pack cleanup\n"); + } + else + return errorUnknownSubcommand(a->argv[0]); + + return RTEXITCODE_SUCCESS; +} + +RTEXITCODE handleUnattendedDetect(HandlerArg *a) +{ + HRESULT hrc; + + /* + * Options. We work directly on an IUnattended instace while parsing + * the options. This saves a lot of extra clutter. + */ + bool fMachineReadable = false; + char szIsoPath[RTPATH_MAX]; + szIsoPath[0] = '\0'; + + /* + * Parse options. + */ + static const RTGETOPTDEF s_aOptions[] = + { + { "--iso", 'i', RTGETOPT_REQ_STRING }, + { "--machine-readable", 'M', RTGETOPT_REQ_NOTHING }, + }; + + RTGETOPTSTATE GetState; + int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(vrc, RTEXITCODE_FAILURE); + + int c; + RTGETOPTUNION ValueUnion; + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case 'i': // --iso + vrc = RTPathAbs(ValueUnion.psz, szIsoPath, sizeof(szIsoPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + break; + + case 'M': // --machine-readable. + fMachineReadable = true; + break; + + default: + return errorGetOpt(c, &ValueUnion); + } + } + + /* + * Check for required stuff. + */ + if (szIsoPath[0] == '\0') + return errorSyntax("No ISO specified"); + + /* + * Do the job. + */ + ComPtr<IUnattended> ptrUnattended; + CHECK_ERROR2_RET(hrc, a->virtualBox, CreateUnattendedInstaller(ptrUnattended.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(IsoPath)(Bstr(szIsoPath).raw()), RTEXITCODE_FAILURE); + CHECK_ERROR2(hrc, ptrUnattended, DetectIsoOS()); + RTEXITCODE rcExit = SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; + + /* + * Retrieve the results. + */ + Bstr bstrDetectedOSTypeId; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSTypeId)(bstrDetectedOSTypeId.asOutParam()), RTEXITCODE_FAILURE); + Bstr bstrDetectedVersion; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSVersion)(bstrDetectedVersion.asOutParam()), RTEXITCODE_FAILURE); + Bstr bstrDetectedFlavor; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSFlavor)(bstrDetectedFlavor.asOutParam()), RTEXITCODE_FAILURE); + Bstr bstrDetectedLanguages; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSLanguages)(bstrDetectedLanguages.asOutParam()), RTEXITCODE_FAILURE); + Bstr bstrDetectedHints; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMGETTER(DetectedOSHints)(bstrDetectedHints.asOutParam()), RTEXITCODE_FAILURE); + if (fMachineReadable) + RTPrintf("OSTypeId=\"%ls\"\n" + "OSVersion=\"%ls\"\n" + "OSFlavor=\"%ls\"\n" + "OSLanguages=\"%ls\"\n" + "OSHints=\"%ls\"\n", + bstrDetectedOSTypeId.raw(), + bstrDetectedVersion.raw(), + bstrDetectedFlavor.raw(), + bstrDetectedLanguages.raw(), + bstrDetectedHints.raw()); + else + { + RTMsgInfo("Detected '%s' to be:\n", szIsoPath); + RTPrintf(" OS TypeId = %ls\n" + " OS Version = %ls\n" + " OS Flavor = %ls\n" + " OS Languages = %ls\n" + " OS Hints = %ls\n", + bstrDetectedOSTypeId.raw(), + bstrDetectedVersion.raw(), + bstrDetectedFlavor.raw(), + bstrDetectedLanguages.raw(), + bstrDetectedHints.raw()); + } + + return rcExit; +} + +RTEXITCODE handleUnattendedInstall(HandlerArg *a) +{ + HRESULT hrc; + char szAbsPath[RTPATH_MAX]; + + /* + * Options. We work directly on an IUnattended instace while parsing + * the options. This saves a lot of extra clutter. + */ + ComPtr<IUnattended> ptrUnattended; + CHECK_ERROR2_RET(hrc, a->virtualBox, CreateUnattendedInstaller(ptrUnattended.asOutParam()), RTEXITCODE_FAILURE); + RTCList<RTCString> arrPackageSelectionAdjustments; + ComPtr<IMachine> ptrMachine; + bool fDryRun = false; + const char *pszSessionType = "none"; + + /* + * Parse options. + */ + static const RTGETOPTDEF s_aOptions[] = + { + { "--iso", 'i', RTGETOPT_REQ_STRING }, + { "--user", 'u', RTGETOPT_REQ_STRING }, + { "--password", 'p', RTGETOPT_REQ_STRING }, + { "--password-file", 'X', RTGETOPT_REQ_STRING }, + { "--full-user-name", 'U', RTGETOPT_REQ_STRING }, + { "--key", 'k', RTGETOPT_REQ_STRING }, + { "--install-additions", 'A', RTGETOPT_REQ_NOTHING }, + { "--no-install-additions", 'N', RTGETOPT_REQ_NOTHING }, + { "--additions-iso", 'a', RTGETOPT_REQ_STRING }, + { "--install-txs", 't', RTGETOPT_REQ_NOTHING }, + { "--no-install-txs", 'T', RTGETOPT_REQ_NOTHING }, + { "--validation-kit-iso", 'K', RTGETOPT_REQ_STRING }, + { "--locale", 'l', RTGETOPT_REQ_STRING }, + { "--country", 'Y', RTGETOPT_REQ_STRING }, + { "--time-zone", 'z', RTGETOPT_REQ_STRING }, + { "--proxy", 'y', RTGETOPT_REQ_STRING }, + { "--hostname", 'H', RTGETOPT_REQ_STRING }, + { "--package-selection-adjustment", 's', RTGETOPT_REQ_STRING }, + { "--dry-run", 'D', RTGETOPT_REQ_NOTHING }, + // advance options: + { "--auxiliary-base-path", 'x', RTGETOPT_REQ_STRING }, + { "--image-index", 'm', RTGETOPT_REQ_UINT32 }, + { "--script-template", 'c', RTGETOPT_REQ_STRING }, + { "--post-install-template", 'C', RTGETOPT_REQ_STRING }, + { "--post-install-command", 'P', RTGETOPT_REQ_STRING }, + { "--extra-install-kernel-parameters", 'I', RTGETOPT_REQ_STRING }, + { "--language", 'L', RTGETOPT_REQ_STRING }, + // start vm related options: + { "--start-vm", 'S', RTGETOPT_REQ_STRING }, + /** @todo Add a --wait option too for waiting for the VM to shut down or + * something like that...? */ + }; + + RTGETOPTSTATE GetState; + int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST); + AssertRCReturn(vrc, RTEXITCODE_FAILURE); + + int c; + RTGETOPTUNION ValueUnion; + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case VINF_GETOPT_NOT_OPTION: + if (ptrMachine.isNotNull()) + return errorSyntax("VM name/UUID given more than once!"); + CHECK_ERROR2_RET(hrc, a->virtualBox, FindMachine(Bstr(ValueUnion.psz).raw(), ptrMachine.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Machine)(ptrMachine), RTEXITCODE_FAILURE); + break; + + case 'i': // --iso + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(IsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 'u': // --user + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(User)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'p': // --password + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Password)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'X': // --password-file + { + Utf8Str strPassword; + RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &strPassword); + if (rcExit != RTEXITCODE_SUCCESS) + return rcExit; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Password)(Bstr(strPassword).raw()), RTEXITCODE_FAILURE); + break; + } + + case 'U': // --full-user-name + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(FullUserName)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'k': // --key + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ProductKey)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'A': // --install-additions + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallGuestAdditions)(TRUE), RTEXITCODE_FAILURE); + break; + case 'N': // --no-install-additions + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallGuestAdditions)(FALSE), RTEXITCODE_FAILURE); + break; + case 'a': // --additions-iso + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AdditionsIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 't': // --install-txs + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallTestExecService)(TRUE), RTEXITCODE_FAILURE); + break; + case 'T': // --no-install-txs + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(InstallTestExecService)(FALSE), RTEXITCODE_FAILURE); + break; + case 'K': // --valiation-kit-iso + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ValidationKitIsoPath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 'l': // --locale + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Locale)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'Y': // --country + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Country)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'z': // --time-zone; + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(TimeZone)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'y': // --proxy + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Proxy)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'H': // --hostname + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Hostname)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 's': // --package-selection-adjustment + arrPackageSelectionAdjustments.append(ValueUnion.psz); + break; + + case 'D': + fDryRun = true; + break; + + case 'x': // --auxiliary-base-path + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(AuxiliaryBasePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 'm': // --image-index + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ImageIndex)(ValueUnion.u32), RTEXITCODE_FAILURE); + break; + + case 'c': // --script-template + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 'C': // --post-install-script-template + vrc = RTPathAbs(ValueUnion.psz, szAbsPath, sizeof(szAbsPath)); + if (RT_FAILURE(vrc)) + return errorSyntax("RTPathAbs failed on '%s': %Rrc", ValueUnion.psz, vrc); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PostInstallScriptTemplatePath)(Bstr(szAbsPath).raw()), RTEXITCODE_FAILURE); + break; + + case 'P': // --post-install-command. + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PostInstallCommand)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'I': // --extra-install-kernel-parameters + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(ExtraInstallKernelParameters)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'L': // --language + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(Language)(Bstr(ValueUnion.psz).raw()), RTEXITCODE_FAILURE); + break; + + case 'S': // --start-vm + pszSessionType = ValueUnion.psz; + break; + + default: + return errorGetOpt(c, &ValueUnion); + } + } + + /* + * Check for required stuff. + */ + if (ptrMachine.isNull()) + return errorSyntax("Missing VM name/UUID"); + + /* + * Set accumulative attributes. + */ + if (arrPackageSelectionAdjustments.size() == 1) + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PackageSelectionAdjustments)(Bstr(arrPackageSelectionAdjustments[0]).raw()), + RTEXITCODE_FAILURE); + else if (arrPackageSelectionAdjustments.size() > 1) + { + RTCString strAdjustments; + strAdjustments.join(arrPackageSelectionAdjustments, ";"); + CHECK_ERROR2_RET(hrc, ptrUnattended, COMSETTER(PackageSelectionAdjustments)(Bstr(strAdjustments).raw()), RTEXITCODE_FAILURE); + } + + /* + * Get details about the machine so we can display them below. + */ + Bstr bstrMachineName; + CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(Name)(bstrMachineName.asOutParam()), RTEXITCODE_FAILURE); + Bstr bstrUuid; + CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(Id)(bstrUuid.asOutParam()), RTEXITCODE_FAILURE); + BSTR bstrInstalledOS; + CHECK_ERROR2_RET(hrc, ptrMachine, COMGETTER(OSTypeId)(&bstrInstalledOS), RTEXITCODE_FAILURE); + Utf8Str strInstalledOS(bstrInstalledOS); + + /* + * Temporarily lock the machine to check whether it's running or not. + * We take this opportunity to disable the first run wizard. + */ + CHECK_ERROR2_RET(hrc, ptrMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + { + ComPtr<IConsole> ptrConsole; + CHECK_ERROR2(hrc, a->session, COMGETTER(Console)(ptrConsole.asOutParam())); + + if ( ptrConsole.isNull() + && SUCCEEDED(hrc) + && ( RTStrICmp(pszSessionType, "gui") == 0 + || RTStrICmp(pszSessionType, "none") == 0)) + { + ComPtr<IMachine> ptrSessonMachine; + CHECK_ERROR2(hrc, a->session, COMGETTER(Machine)(ptrSessonMachine.asOutParam())); + if (ptrSessonMachine.isNotNull()) + { + CHECK_ERROR2(hrc, ptrSessonMachine, SetExtraData(Bstr("GUI/FirstRun").raw(), Bstr("0").raw())); + } + } + + a->session->UnlockMachine(); + if (FAILED(hrc)) + return RTEXITCODE_FAILURE; + if (ptrConsole.isNotNull()) + return RTMsgErrorExit(RTEXITCODE_FAILURE, "Machine '%ls' is currently running", bstrMachineName.raw()); + } + + /* + * Do the work. + */ + RTMsgInfo("%s unattended installation of %s in machine '%ls' (%ls).\n", + RTStrICmp(pszSessionType, "none") == 0 ? "Preparing" : "Starting", + strInstalledOS.c_str(), bstrMachineName.raw(), bstrUuid.raw()); + + CHECK_ERROR2_RET(hrc, ptrUnattended,Prepare(), RTEXITCODE_FAILURE); + if (!fDryRun) + { + CHECK_ERROR2_RET(hrc, ptrUnattended, ConstructMedia(), RTEXITCODE_FAILURE); + CHECK_ERROR2_RET(hrc, ptrUnattended,ReconfigureVM(), RTEXITCODE_FAILURE); + } + + /* + * Retrieve and display the parameters actually used. + */ + RTMsgInfo("Using values:\n"); +#define SHOW_ATTR(a_Attr, a_szText, a_Type, a_szFmt) do { \ + a_Type Value; \ + HRESULT hrc2 = ptrUnattended->COMGETTER(a_Attr)(&Value); \ + if (SUCCEEDED(hrc2)) \ + RTPrintf(" %32s = " a_szFmt "\n", a_szText, Value); \ + else \ + RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \ + } while (0) +#define SHOW_STR_ATTR(a_Attr, a_szText) do { \ + Bstr bstrString; \ + HRESULT hrc2 = ptrUnattended->COMGETTER(a_Attr)(bstrString.asOutParam()); \ + if (SUCCEEDED(hrc2)) \ + RTPrintf(" %32s = %ls\n", a_szText, bstrString.raw()); \ + else \ + RTPrintf(" %32s = failed: %Rhrc\n", a_szText, hrc2); \ + } while (0) + + SHOW_STR_ATTR(IsoPath, "isoPath"); + SHOW_STR_ATTR(User, "user"); + SHOW_STR_ATTR(Password, "password"); + SHOW_STR_ATTR(FullUserName, "fullUserName"); + SHOW_STR_ATTR(ProductKey, "productKey"); + SHOW_STR_ATTR(AdditionsIsoPath, "additionsIsoPath"); + SHOW_ATTR( InstallGuestAdditions, "installGuestAdditions", BOOL, "%RTbool"); + SHOW_STR_ATTR(ValidationKitIsoPath, "validationKitIsoPath"); + SHOW_ATTR( InstallTestExecService, "installTestExecService", BOOL, "%RTbool"); + SHOW_STR_ATTR(Locale, "locale"); + SHOW_STR_ATTR(Country, "country"); + SHOW_STR_ATTR(TimeZone, "timeZone"); + SHOW_STR_ATTR(Proxy, "proxy"); + SHOW_STR_ATTR(Hostname, "hostname"); + SHOW_STR_ATTR(PackageSelectionAdjustments, "packageSelectionAdjustments"); + SHOW_STR_ATTR(AuxiliaryBasePath, "auxiliaryBasePath"); + SHOW_ATTR( ImageIndex, "imageIndex", ULONG, "%u"); + SHOW_STR_ATTR(ScriptTemplatePath, "scriptTemplatePath"); + SHOW_STR_ATTR(PostInstallScriptTemplatePath, "postInstallScriptTemplatePath"); + SHOW_STR_ATTR(PostInstallCommand, "postInstallCommand"); + SHOW_STR_ATTR(ExtraInstallKernelParameters, "extraInstallKernelParameters"); + SHOW_STR_ATTR(Language, "language"); + SHOW_STR_ATTR(DetectedOSTypeId, "detectedOSTypeId"); + SHOW_STR_ATTR(DetectedOSVersion, "detectedOSVersion"); + SHOW_STR_ATTR(DetectedOSFlavor, "detectedOSFlavor"); + SHOW_STR_ATTR(DetectedOSLanguages, "detectedOSLanguages"); + SHOW_STR_ATTR(DetectedOSHints, "detectedOSHints"); + +#undef SHOW_STR_ATTR +#undef SHOW_ATTR + + /* We can drop the IUnatteded object now. */ + ptrUnattended.setNull(); + + /* + * Start the VM if requested. + */ + if ( fDryRun + || RTStrICmp(pszSessionType, "none") == 0) + { + if (!fDryRun) + RTMsgInfo("VM '%ls' (%ls) is ready to be started (e.g. VBoxManage startvm).\n", bstrMachineName.raw(), bstrUuid.raw()); + hrc = S_OK; + } + else + { + Bstr env; +#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS) + /* make sure the VM process will start on the same display as VBoxManage */ + Utf8Str str; + const char *pszDisplay = RTEnvGet("DISPLAY"); + if (pszDisplay) + str = Utf8StrFmt("DISPLAY=%s\n", pszDisplay); + const char *pszXAuth = RTEnvGet("XAUTHORITY"); + if (pszXAuth) + str.append(Utf8StrFmt("XAUTHORITY=%s\n", pszXAuth)); + env = str; +#endif + ComPtr<IProgress> ptrProgress; + CHECK_ERROR2(hrc, ptrMachine, LaunchVMProcess(a->session, Bstr(pszSessionType).raw(), env.raw(), ptrProgress.asOutParam())); + if (SUCCEEDED(hrc) && !ptrProgress.isNull()) + { + RTMsgInfo("Waiting for VM '%ls' to power on...\n", bstrMachineName.raw()); + CHECK_ERROR2(hrc, ptrProgress, WaitForCompletion(-1)); + if (SUCCEEDED(hrc)) + { + BOOL fCompleted = true; + CHECK_ERROR2(hrc, ptrProgress, COMGETTER(Completed)(&fCompleted)); + if (SUCCEEDED(hrc)) + { + ASSERT(fCompleted); + + LONG iRc; + CHECK_ERROR2(hrc, ptrProgress, COMGETTER(ResultCode)(&iRc)); + if (SUCCEEDED(hrc)) + { + if (SUCCEEDED(iRc)) + RTMsgInfo("VM '%ls' (%ls) has been successfully started.\n", bstrMachineName.raw(), bstrUuid.raw()); + else + { + ProgressErrorInfo info(ptrProgress); + com::GluePrintErrorInfo(info); + } + hrc = iRc; + } + } + } + } + + /* + * Do we wait for the VM to power down? + */ + } + + return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +RTEXITCODE handleUnattended(HandlerArg *a) +{ + /* + * Sub-command switch. + */ + if (a->argc < 1) + return errorNoSubcommand(); + + if (!strcmp(a->argv[0], "detect")) + { + setCurrentSubcommand(HELP_SCOPE_UNATTENDED_DETECT); + return handleUnattendedDetect(a); + } + + if (!strcmp(a->argv[0], "install")) + { + setCurrentSubcommand(HELP_SCOPE_UNATTENDED_INSTALL); + return handleUnattendedInstall(a); + } + + /* Consider some kind of create-vm-and-install-guest-os command. */ + return errorUnknownSubcommand(a->argv[0]); +} diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp new file mode 100644 index 00000000..6ecda59e --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp @@ -0,0 +1,3202 @@ +/* $Id: VBoxManageModifyVM.cpp $ */ +/** @file + * VBoxManage - Implementation of modifyvm command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#include <iprt/cidr.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/getopt.h> +#include <VBox/log.h> +#include "VBoxManage.h" + +#ifndef VBOX_ONLY_DOCS +using namespace com; +/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */ +#if defined(_MSC_VER) +# pragma optimize("g", off) +# if _MSC_VER < RT_MSC_VER_VC120 +# pragma warning(disable:4748) +# endif +#endif + +enum +{ + MODIFYVM_NAME = 1000, + MODIFYVM_GROUPS, + MODIFYVM_DESCRIPTION, + MODIFYVM_OSTYPE, + MODIFYVM_ICONFILE, + MODIFYVM_MEMORY, + MODIFYVM_PAGEFUSION, + MODIFYVM_VRAM, + MODIFYVM_FIRMWARE, + MODIFYVM_ACPI, + MODIFYVM_IOAPIC, + MODIFYVM_PAE, + MODIFYVM_LONGMODE, + MODIFYVM_CPUID_PORTABILITY, + MODIFYVM_TFRESET, + MODIFYVM_APIC, + MODIFYVM_X2APIC, + MODIFYVM_PARAVIRTPROVIDER, + MODIFYVM_PARAVIRTDEBUG, + MODIFYVM_HWVIRTEX, + MODIFYVM_NESTEDPAGING, + MODIFYVM_LARGEPAGES, + MODIFYVM_VTXVPID, + MODIFYVM_VTXUX, + MODIFYVM_IBPB_ON_VM_EXIT, + MODIFYVM_IBPB_ON_VM_ENTRY, + MODIFYVM_SPEC_CTRL, + MODIFYVM_L1D_FLUSH_ON_SCHED, + MODIFYVM_L1D_FLUSH_ON_VM_ENTRY, + MODIFYVM_NESTED_HW_VIRT, + MODIFYVM_CPUS, + MODIFYVM_CPUHOTPLUG, + MODIFYVM_CPU_PROFILE, + MODIFYVM_PLUGCPU, + MODIFYVM_UNPLUGCPU, + MODIFYVM_SETCPUID, + MODIFYVM_SETCPUID_OLD, + MODIFYVM_DELCPUID, + MODIFYVM_DELCPUID_OLD, + MODIFYVM_DELALLCPUID, + MODIFYVM_GRAPHICSCONTROLLER, + MODIFYVM_MONITORCOUNT, + MODIFYVM_ACCELERATE3D, +#ifdef VBOX_WITH_VIDEOHWACCEL + MODIFYVM_ACCELERATE2DVIDEO, +#endif + MODIFYVM_BIOSLOGOFADEIN, + MODIFYVM_BIOSLOGOFADEOUT, + MODIFYVM_BIOSLOGODISPLAYTIME, + MODIFYVM_BIOSLOGOIMAGEPATH, + MODIFYVM_BIOSBOOTMENU, + MODIFYVM_BIOSAPIC, + MODIFYVM_BIOSSYSTEMTIMEOFFSET, + MODIFYVM_BIOSPXEDEBUG, + MODIFYVM_BOOT, + MODIFYVM_HDA, // deprecated + MODIFYVM_HDB, // deprecated + MODIFYVM_HDD, // deprecated + MODIFYVM_IDECONTROLLER, // deprecated + MODIFYVM_SATAPORTCOUNT, // deprecated + MODIFYVM_SATAPORT, // deprecated + MODIFYVM_SATA, // deprecated + MODIFYVM_SCSIPORT, // deprecated + MODIFYVM_SCSITYPE, // deprecated + MODIFYVM_SCSI, // deprecated + MODIFYVM_DVDPASSTHROUGH, // deprecated + MODIFYVM_DVD, // deprecated + MODIFYVM_FLOPPY, // deprecated + MODIFYVM_NICTRACEFILE, + MODIFYVM_NICTRACE, + MODIFYVM_NICPROPERTY, + MODIFYVM_NICTYPE, + MODIFYVM_NICSPEED, + MODIFYVM_NICBOOTPRIO, + MODIFYVM_NICPROMISC, + MODIFYVM_NICBWGROUP, + MODIFYVM_NIC, + MODIFYVM_CABLECONNECTED, + MODIFYVM_BRIDGEADAPTER, + MODIFYVM_HOSTONLYADAPTER, + MODIFYVM_INTNET, + MODIFYVM_GENERICDRV, + MODIFYVM_NATNETWORKNAME, + MODIFYVM_NATNET, + MODIFYVM_NATBINDIP, + MODIFYVM_NATSETTINGS, + MODIFYVM_NATPF, + MODIFYVM_NATALIASMODE, + MODIFYVM_NATTFTPPREFIX, + MODIFYVM_NATTFTPFILE, + MODIFYVM_NATTFTPSERVER, + MODIFYVM_NATDNSPASSDOMAIN, + MODIFYVM_NATDNSPROXY, + MODIFYVM_NATDNSHOSTRESOLVER, + MODIFYVM_MACADDRESS, + MODIFYVM_HIDPTR, + MODIFYVM_HIDKBD, + MODIFYVM_UARTMODE, + MODIFYVM_UARTTYPE, + MODIFYVM_UART, +#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS) + MODIFYVM_LPTMODE, + MODIFYVM_LPT, +#endif + MODIFYVM_GUESTMEMORYBALLOON, + MODIFYVM_AUDIOCONTROLLER, + MODIFYVM_AUDIOCODEC, + MODIFYVM_AUDIO, + MODIFYVM_AUDIOIN, + MODIFYVM_AUDIOOUT, + MODIFYVM_CLIPBOARD, + MODIFYVM_DRAGANDDROP, + MODIFYVM_VRDPPORT, /* VRDE: deprecated */ + MODIFYVM_VRDPADDRESS, /* VRDE: deprecated */ + MODIFYVM_VRDPAUTHTYPE, /* VRDE: deprecated */ + MODIFYVM_VRDPMULTICON, /* VRDE: deprecated */ + MODIFYVM_VRDPREUSECON, /* VRDE: deprecated */ + MODIFYVM_VRDPVIDEOCHANNEL, /* VRDE: deprecated */ + MODIFYVM_VRDPVIDEOCHANNELQUALITY, /* VRDE: deprecated */ + MODIFYVM_VRDP, /* VRDE: deprecated */ + MODIFYVM_VRDEPROPERTY, + MODIFYVM_VRDEPORT, + MODIFYVM_VRDEADDRESS, + MODIFYVM_VRDEAUTHTYPE, + MODIFYVM_VRDEAUTHLIBRARY, + MODIFYVM_VRDEMULTICON, + MODIFYVM_VRDEREUSECON, + MODIFYVM_VRDEVIDEOCHANNEL, + MODIFYVM_VRDEVIDEOCHANNELQUALITY, + MODIFYVM_VRDE_EXTPACK, + MODIFYVM_VRDE, + MODIFYVM_RTCUSEUTC, + MODIFYVM_USBRENAME, + MODIFYVM_USBXHCI, + MODIFYVM_USBEHCI, + MODIFYVM_USBOHCI, + MODIFYVM_SNAPSHOTFOLDER, + MODIFYVM_TELEPORTER_ENABLED, + MODIFYVM_TELEPORTER_PORT, + MODIFYVM_TELEPORTER_ADDRESS, + MODIFYVM_TELEPORTER_PASSWORD, + MODIFYVM_TELEPORTER_PASSWORD_FILE, + MODIFYVM_TRACING_ENABLED, + MODIFYVM_TRACING_CONFIG, + MODIFYVM_TRACING_ALLOW_VM_ACCESS, + MODIFYVM_HARDWARE_UUID, + MODIFYVM_HPET, + MODIFYVM_IOCACHE, + MODIFYVM_IOCACHESIZE, + MODIFYVM_FAULT_TOLERANCE, + MODIFYVM_FAULT_TOLERANCE_ADDRESS, + MODIFYVM_FAULT_TOLERANCE_PORT, + MODIFYVM_FAULT_TOLERANCE_PASSWORD, + MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, + MODIFYVM_CPU_EXECTUION_CAP, + MODIFYVM_AUTOSTART_ENABLED, + MODIFYVM_AUTOSTART_DELAY, + MODIFYVM_AUTOSTOP_TYPE, +#ifdef VBOX_WITH_PCI_PASSTHROUGH + MODIFYVM_ATTACH_PCI, + MODIFYVM_DETACH_PCI, +#endif +#ifdef VBOX_WITH_USB_CARDREADER + MODIFYVM_USBCARDREADER, +#endif +#ifdef VBOX_WITH_RECORDING + MODIFYVM_RECORDING, + MODIFYVM_RECORDING_FEATURES, + MODIFYVM_RECORDING_SCREENS, + MODIFYVM_RECORDING_FILENAME, + MODIFYVM_RECORDING_VIDEO_WIDTH, + MODIFYVM_RECORDING_VIDEO_HEIGHT, + MODIFYVM_RECORDING_VIDEO_RES, + MODIFYVM_RECORDING_VIDEO_RATE, + MODIFYVM_RECORDING_VIDEO_FPS, + MODIFYVM_RECORDING_MAXTIME, + MODIFYVM_RECORDING_MAXSIZE, + MODIFYVM_RECORDING_OPTIONS, +#endif + MODIFYVM_CHIPSET, + MODIFYVM_DEFAULTFRONTEND +}; + +static const RTGETOPTDEF g_aModifyVMOptions[] = +{ +/** @todo Convert to dash separated names like --triple-fault-reset! Please + * do that for all new options as we don't need more character soups + * around VirtualBox - typedefs more than covers that demand! */ + { "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING }, + { "--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING }, + { "--description", MODIFYVM_DESCRIPTION, RTGETOPT_REQ_STRING }, + { "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING }, + { "--iconfile", MODIFYVM_ICONFILE, RTGETOPT_REQ_STRING }, + { "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 }, + { "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 }, + { "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING }, + { "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF }, + { "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF }, + { "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF }, + { "--longmode", MODIFYVM_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF }, + { "--cpuid-portability-level", MODIFYVM_CPUID_PORTABILITY, RTGETOPT_REQ_UINT32 }, + { "--triplefaultreset", MODIFYVM_TFRESET, RTGETOPT_REQ_BOOL_ONOFF }, + { "--apic", MODIFYVM_APIC, RTGETOPT_REQ_BOOL_ONOFF }, + { "--x2apic", MODIFYVM_X2APIC, RTGETOPT_REQ_BOOL_ONOFF }, + { "--paravirtprovider", MODIFYVM_PARAVIRTPROVIDER, RTGETOPT_REQ_STRING }, + { "--paravirtdebug", MODIFYVM_PARAVIRTDEBUG, RTGETOPT_REQ_STRING }, + { "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF }, + { "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF }, + { "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vtxux", MODIFYVM_VTXUX, RTGETOPT_REQ_BOOL_ONOFF }, + { "--ibpb-on-vm-exit", MODIFYVM_IBPB_ON_VM_EXIT, RTGETOPT_REQ_BOOL_ONOFF }, + { "--ibpb-on-vm-entry", MODIFYVM_IBPB_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF }, + { "--spec-ctrl", MODIFYVM_SPEC_CTRL, RTGETOPT_REQ_BOOL_ONOFF }, + { "--l1d-flush-on-sched", MODIFYVM_L1D_FLUSH_ON_SCHED, RTGETOPT_REQ_BOOL_ONOFF }, + { "--l1d-flush-on-vm-entry", MODIFYVM_L1D_FLUSH_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF }, + { "--nested-hw-virt", MODIFYVM_NESTED_HW_VIRT, RTGETOPT_REQ_BOOL_ONOFF }, + { "--cpuid-set", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX }, + { "--cpuid-remove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX }, + { "--cpuidset", MODIFYVM_SETCPUID_OLD, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX }, + { "--cpuidremove", MODIFYVM_DELCPUID_OLD, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX }, + { "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING}, + { "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 }, + { "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF }, + { "--cpu-profile", MODIFYVM_CPU_PROFILE, RTGETOPT_REQ_STRING }, + { "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 }, + { "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 }, + { "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32 }, + { "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF }, + { "--graphicscontroller", MODIFYVM_GRAPHICSCONTROLLER, RTGETOPT_REQ_STRING }, + { "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 }, + { "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF }, +#ifdef VBOX_WITH_VIDEOHWACCEL + { "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF }, +#endif + { "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF }, + { "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF }, + { "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 }, + { "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING }, + { "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING }, + { "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 }, + { "--biosapic", MODIFYVM_BIOSAPIC, RTGETOPT_REQ_STRING }, + { "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF }, + { "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING }, + { "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING }, + { "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING }, + { "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING }, + { "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 }, + { "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING }, + { "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING }, + { "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING }, + { "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING }, + { "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING }, + { "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING }, + { "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX }, + { "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX }, + { "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX }, + { "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX }, + { "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nat-network", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natnetwork", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX }, + { "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX }, + { "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX }, + { "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING }, + { "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING }, + { "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--uarttype", MODIFYVM_UARTTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, +#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS) + { "--lptmode", MODIFYVM_LPTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, + { "--lpt", MODIFYVM_LPT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX }, +#endif + { "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 }, + { "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING }, + { "--audiocodec", MODIFYVM_AUDIOCODEC, RTGETOPT_REQ_STRING }, + { "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING }, + { "--audioin", MODIFYVM_AUDIOIN, RTGETOPT_REQ_BOOL_ONOFF }, + { "--audioout", MODIFYVM_AUDIOOUT, RTGETOPT_REQ_BOOL_ONOFF }, + { "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING }, + { "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING }, + { "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING }, /* deprecated */ + { "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING }, /* deprecated */ + { "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING }, /* deprecated */ + { "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, /* deprecated */ + { "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING }, + { "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING }, + { "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING }, + { "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING }, + { "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING }, + { "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF }, + { "--vrdevideochannelquality", MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, + { "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING }, + { "--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF }, + { "--usbrename", MODIFYVM_USBRENAME, RTGETOPT_REQ_STRING }, + { "--usbxhci", MODIFYVM_USBXHCI, RTGETOPT_REQ_BOOL_ONOFF }, + { "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF }, + { "--usbohci", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF }, + { "--usb", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING }, + { "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, + { "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */ + { "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 }, + { "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING }, + { "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING }, + { "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING }, + { "--tracing-enabled", MODIFYVM_TRACING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, + { "--tracing-config", MODIFYVM_TRACING_CONFIG, RTGETOPT_REQ_STRING }, + { "--tracing-allow-vm-access", MODIFYVM_TRACING_ALLOW_VM_ACCESS, RTGETOPT_REQ_BOOL_ONOFF }, + { "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING }, + { "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF }, + { "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF }, + { "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 }, + { "--faulttolerance", MODIFYVM_FAULT_TOLERANCE, RTGETOPT_REQ_STRING }, + { "--faulttoleranceaddress", MODIFYVM_FAULT_TOLERANCE_ADDRESS, RTGETOPT_REQ_STRING }, + { "--faulttoleranceport", MODIFYVM_FAULT_TOLERANCE_PORT, RTGETOPT_REQ_UINT32 }, + { "--faulttolerancepassword", MODIFYVM_FAULT_TOLERANCE_PASSWORD, RTGETOPT_REQ_STRING }, + { "--faulttolerancesyncinterval", MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, RTGETOPT_REQ_UINT32 }, + { "--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING }, +#ifdef VBOX_WITH_RECORDING + { "--recording", MODIFYVM_RECORDING, RTGETOPT_REQ_BOOL_ONOFF }, + { "--recordingscreens", MODIFYVM_RECORDING_SCREENS, RTGETOPT_REQ_STRING }, + { "--recordingfile", MODIFYVM_RECORDING_FILENAME, RTGETOPT_REQ_STRING }, + { "--recordingmaxtime", MODIFYVM_RECORDING_MAXTIME, RTGETOPT_REQ_INT32 }, + { "--recordingmaxsize", MODIFYVM_RECORDING_MAXSIZE, RTGETOPT_REQ_INT32 }, + { "--recordingopts", MODIFYVM_RECORDING_OPTIONS, RTGETOPT_REQ_STRING }, + { "--recordingoptions", MODIFYVM_RECORDING_OPTIONS, RTGETOPT_REQ_STRING }, + { "--recordingvideores", MODIFYVM_RECORDING_VIDEO_RES, RTGETOPT_REQ_STRING }, + { "--recordingvideoresolution", MODIFYVM_RECORDING_VIDEO_RES, RTGETOPT_REQ_STRING }, + { "--recordingvideorate", MODIFYVM_RECORDING_VIDEO_RATE, RTGETOPT_REQ_UINT32 }, + { "--recordingvideofps", MODIFYVM_RECORDING_VIDEO_FPS, RTGETOPT_REQ_UINT32 }, +#endif + { "--autostart-enabled", MODIFYVM_AUTOSTART_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, + { "--autostart-delay", MODIFYVM_AUTOSTART_DELAY, RTGETOPT_REQ_UINT32 }, + { "--autostop-type", MODIFYVM_AUTOSTOP_TYPE, RTGETOPT_REQ_STRING }, +#ifdef VBOX_WITH_PCI_PASSTHROUGH + { "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING }, + { "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING }, +#endif +#ifdef VBOX_WITH_USB_CARDREADER + { "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF }, +#endif + { "--defaultfrontend", MODIFYVM_DEFAULTFRONTEND, RTGETOPT_REQ_STRING }, +}; + +static void vrdeWarningDeprecatedOption(const char *pszOption) +{ + RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption); +} + +/** Parse PCI address in format 01:02.03 and convert it to the numeric representation. */ +static int32_t parsePci(const char* szPciAddr) +{ + char* pszNext = (char*)szPciAddr; + int rc; + uint8_t aVals[3] = {0, 0, 0}; + + rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]); + if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != ':') + return -1; + + rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]); + if (RT_FAILURE(rc) || pszNext == NULL || *pszNext != '.') + return -1; + + rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]); + if (RT_FAILURE(rc) || pszNext == NULL) + return -1; + + return (aVals[0] << 8) | (aVals[1] << 3) | (aVals[2] << 0); +} + +void parseGroups(const char *pcszGroups, com::SafeArray<BSTR> *pGroups) +{ + while (pcszGroups) + { + char *pComma = RTStrStr(pcszGroups, ","); + if (pComma) + { + Bstr(pcszGroups, pComma - pcszGroups).detachTo(pGroups->appendedRaw()); + pcszGroups = pComma + 1; + } + else + { + Bstr(pcszGroups).detachTo(pGroups->appendedRaw()); + pcszGroups = NULL; + } + } +} + +#ifdef VBOX_WITH_RECORDING +static int parseScreens(const char *pcszScreens, com::SafeArray<BOOL> *pScreens) +{ + while (pcszScreens && *pcszScreens) + { + char *pszNext; + uint32_t iScreen; + int rc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen); + if (RT_FAILURE(rc)) + return 1; + if (iScreen >= pScreens->size()) + return 1; + if (pszNext && *pszNext) + { + pszNext = RTStrStripL(pszNext); + if (*pszNext != ',') + return 1; + pszNext++; + } + (*pScreens)[iScreen] = true; + pcszScreens = pszNext; + } + return 0; +} +#endif + +static int parseNum(uint32_t uIndex, unsigned cMaxIndex, const char *pszName) +{ + if ( uIndex >= 1 + && uIndex <= cMaxIndex) + return uIndex; + errorArgument("Invalid %s number %u", pszName, uIndex); + return 0; +} + +RTEXITCODE handleModifyVM(HandlerArg *a) +{ + int c; + HRESULT rc; + Bstr name; + + /* VM ID + at least one parameter. Parameter arguments are checked + * individually. */ + if (a->argc < 2) + return errorSyntax(USAGE_MODIFYVM, "Not enough parameters"); + + /* try to find the given sessionMachine */ + ComPtr<IMachine> machine; + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam()), RTEXITCODE_FAILURE); + + + /* Get the number of network adapters */ + ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine); + + /* open a session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE); + + /* get the mutable session sessionMachine */ + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE); + + ComPtr<IBIOSSettings> biosSettings; + sessionMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam()); + + RTGETOPTSTATE GetOptState; + RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions, + RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + RTGETOPTUNION ValueUnion; + while ( SUCCEEDED (rc) + && (c = RTGetOpt(&GetOptState, &ValueUnion))) + { + switch (c) + { + case MODIFYVM_NAME: + { + CHECK_ERROR(sessionMachine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw())); + break; + } + case MODIFYVM_GROUPS: + { + com::SafeArray<BSTR> groups; + parseGroups(ValueUnion.psz, &groups); + CHECK_ERROR(sessionMachine, COMSETTER(Groups)(ComSafeArrayAsInParam(groups))); + break; + } + case MODIFYVM_DESCRIPTION: + { + CHECK_ERROR(sessionMachine, COMSETTER(Description)(Bstr(ValueUnion.psz).raw())); + break; + } + case MODIFYVM_OSTYPE: + { + CHECK_ERROR(sessionMachine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_ICONFILE: + { + RTFILE iconFile; + int vrc = RTFileOpen(&iconFile, ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot open file \"%s\": %Rrc", ValueUnion.psz, vrc); + rc = E_FAIL; + break; + } + uint64_t cbSize; + vrc = RTFileGetSize(iconFile, &cbSize); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot get size of file \"%s\": %Rrc", ValueUnion.psz, vrc); + rc = E_FAIL; + break; + } + if (cbSize > _256K) + { + RTMsgError("File \"%s\" is bigger than 256KByte", ValueUnion.psz); + rc = E_FAIL; + break; + } + SafeArray<BYTE> icon((size_t)cbSize); + rc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL); + if (RT_FAILURE(vrc)) + { + RTMsgError("Cannot read contents of file \"%s\": %Rrc", ValueUnion.psz, vrc); + rc = E_FAIL; + break; + } + RTFileClose(iconFile); + CHECK_ERROR(sessionMachine, COMSETTER(Icon)(ComSafeArrayAsInParam(icon))); + break; + } + + case MODIFYVM_MEMORY: + { + CHECK_ERROR(sessionMachine, COMSETTER(MemorySize)(ValueUnion.u32)); + break; + } + + case MODIFYVM_PAGEFUSION: + { + CHECK_ERROR(sessionMachine, COMSETTER(PageFusionEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_VRAM: + { + CHECK_ERROR(sessionMachine, COMSETTER(VRAMSize)(ValueUnion.u32)); + break; + } + + case MODIFYVM_FIRMWARE: + { + if (!RTStrICmp(ValueUnion.psz, "efi")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI)); + } + else if (!RTStrICmp(ValueUnion.psz, "efi32")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI32)); + } + else if (!RTStrICmp(ValueUnion.psz, "efi64")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI64)); + } + else if (!RTStrICmp(ValueUnion.psz, "efidual")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL)); + } + else if (!RTStrICmp(ValueUnion.psz, "bios")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_BIOS)); + } + else + { + errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_ACPI: + { + CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_IOAPIC: + { + CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_PAE: + { + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f)); + break; + } + + case MODIFYVM_LONGMODE: + { + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_LongMode, ValueUnion.f)); + break; + } + + case MODIFYVM_CPUID_PORTABILITY: + { + CHECK_ERROR(sessionMachine, COMSETTER(CPUIDPortabilityLevel)(ValueUnion.u32)); + break; + } + + case MODIFYVM_TFRESET: + { + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_TripleFaultReset, ValueUnion.f)); + break; + } + + case MODIFYVM_APIC: + { + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_APIC, ValueUnion.f)); + break; + } + + case MODIFYVM_X2APIC: + { + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_X2APIC, ValueUnion.f)); + break; + } + + case MODIFYVM_PARAVIRTPROVIDER: + { + if ( !RTStrICmp(ValueUnion.psz, "none") + || !RTStrICmp(ValueUnion.psz, "disabled")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_None)); + else if (!RTStrICmp(ValueUnion.psz, "default")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Default)); + else if (!RTStrICmp(ValueUnion.psz, "legacy")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Legacy)); + else if (!RTStrICmp(ValueUnion.psz, "minimal")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Minimal)); + else if (!RTStrICmp(ValueUnion.psz, "hyperv")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_HyperV)); + else if (!RTStrICmp(ValueUnion.psz, "kvm")) + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_KVM)); + else + { + errorArgument("Invalid --paravirtprovider argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_PARAVIRTDEBUG: + { + CHECK_ERROR(sessionMachine, COMSETTER(ParavirtDebug)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_HWVIRTEX: + { + CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f)); + break; + } + + case MODIFYVM_SETCPUID: + case MODIFYVM_SETCPUID_OLD: + { + uint32_t const idx = c == MODIFYVM_SETCPUID ? ValueUnion.PairU32.uFirst : ValueUnion.u32; + uint32_t const idxSub = c == MODIFYVM_SETCPUID ? ValueUnion.PairU32.uSecond : UINT32_MAX; + uint32_t aValue[4]; + for (unsigned i = 0; i < 4; i++) + { + int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, "Missing or Invalid argument to '%s'", GetOptState.pDef->pszLong); + aValue[i] = ValueUnion.u32; + } + CHECK_ERROR(sessionMachine, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3])); + break; + } + + case MODIFYVM_DELCPUID: + CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.PairU32.uFirst, ValueUnion.PairU32.uSecond)); + break; + + case MODIFYVM_DELCPUID_OLD: + CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.u32, UINT32_MAX)); + break; + + case MODIFYVM_DELALLCPUID: + { + CHECK_ERROR(sessionMachine, RemoveAllCPUIDLeaves()); + break; + } + + case MODIFYVM_NESTEDPAGING: + { + CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f)); + break; + } + + case MODIFYVM_LARGEPAGES: + { + CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f)); + break; + } + + case MODIFYVM_VTXVPID: + { + CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f)); + break; + } + + case MODIFYVM_VTXUX: + { + CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, ValueUnion.f)); + break; + } + + case MODIFYVM_IBPB_ON_VM_EXIT: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_IBPBOnVMExit, ValueUnion.f)); + break; + + case MODIFYVM_IBPB_ON_VM_ENTRY: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_IBPBOnVMEntry, ValueUnion.f)); + break; + + case MODIFYVM_SPEC_CTRL: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_SpecCtrl, ValueUnion.f)); + break; + + case MODIFYVM_L1D_FLUSH_ON_SCHED: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_L1DFlushOnEMTScheduling, ValueUnion.f)); + break; + + case MODIFYVM_L1D_FLUSH_ON_VM_ENTRY: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_L1DFlushOnVMEntry, ValueUnion.f)); + break; + + case MODIFYVM_NESTED_HW_VIRT: + CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_HWVirt, ValueUnion.f)); + break; + + case MODIFYVM_CPUS: + { + CHECK_ERROR(sessionMachine, COMSETTER(CPUCount)(ValueUnion.u32)); + break; + } + + case MODIFYVM_RTCUSEUTC: + { + CHECK_ERROR(sessionMachine, COMSETTER(RTCUseUTC)(ValueUnion.f)); + break; + } + + case MODIFYVM_CPUHOTPLUG: + { + CHECK_ERROR(sessionMachine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_CPU_PROFILE: + { + CHECK_ERROR(sessionMachine, COMSETTER(CPUProfile)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_PLUGCPU: + { + CHECK_ERROR(sessionMachine, HotPlugCPU(ValueUnion.u32)); + break; + } + + case MODIFYVM_UNPLUGCPU: + { + CHECK_ERROR(sessionMachine, HotUnplugCPU(ValueUnion.u32)); + break; + } + + case MODIFYVM_CPU_EXECTUION_CAP: + { + CHECK_ERROR(sessionMachine, COMSETTER(CPUExecutionCap)(ValueUnion.u32)); + break; + } + + case MODIFYVM_GRAPHICSCONTROLLER: + { + if ( !RTStrICmp(ValueUnion.psz, "none") + || !RTStrICmp(ValueUnion.psz, "disabled")) + CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_Null)); + else if ( !RTStrICmp(ValueUnion.psz, "vboxvga") + || !RTStrICmp(ValueUnion.psz, "vbox") + || !RTStrICmp(ValueUnion.psz, "vga") + || !RTStrICmp(ValueUnion.psz, "vesa")) + CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxVGA)); +#ifdef VBOX_WITH_VMSVGA + else if ( !RTStrICmp(ValueUnion.psz, "vmsvga") + || !RTStrICmp(ValueUnion.psz, "vmware")) + CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VMSVGA)); + else if ( !RTStrICmp(ValueUnion.psz, "vboxsvga") + || !RTStrICmp(ValueUnion.psz, "svga")) + CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxSVGA)); +#endif + else + { + errorArgument("Invalid --graphicscontroller argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_MONITORCOUNT: + { + CHECK_ERROR(sessionMachine, COMSETTER(MonitorCount)(ValueUnion.u32)); + break; + } + + case MODIFYVM_ACCELERATE3D: + { + CHECK_ERROR(sessionMachine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f)); + break; + } + +#ifdef VBOX_WITH_VIDEOHWACCEL + case MODIFYVM_ACCELERATE2DVIDEO: + { + CHECK_ERROR(sessionMachine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f)); + break; + } +#endif + + case MODIFYVM_BIOSLOGOFADEIN: + { + CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f)); + break; + } + + case MODIFYVM_BIOSLOGOFADEOUT: + { + CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f)); + break; + } + + case MODIFYVM_BIOSLOGODISPLAYTIME: + { + CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32)); + break; + } + + case MODIFYVM_BIOSLOGOIMAGEPATH: + { + CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_BIOSBOOTMENU: + { + if (!RTStrICmp(ValueUnion.psz, "disabled")) + { + CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled)); + } + else if (!RTStrICmp(ValueUnion.psz, "menuonly")) + { + CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly)); + } + else if (!RTStrICmp(ValueUnion.psz, "messageandmenu")) + { + CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu)); + } + else + { + errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_BIOSAPIC: + { + if (!RTStrICmp(ValueUnion.psz, "disabled")) + { + CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_Disabled)); + } + else if ( !RTStrICmp(ValueUnion.psz, "apic") + || !RTStrICmp(ValueUnion.psz, "lapic") + || !RTStrICmp(ValueUnion.psz, "xapic")) + { + CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_APIC)); + } + else if (!RTStrICmp(ValueUnion.psz, "x2apic")) + { + CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_X2APIC)); + } + else + { + errorArgument("Invalid --biosapic argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_BIOSSYSTEMTIMEOFFSET: + { + CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64)); + break; + } + + case MODIFYVM_BIOSPXEDEBUG: + { + CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_BOOT: + { + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Null)); + } + else if (!RTStrICmp(ValueUnion.psz, "floppy")) + { + CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy)); + } + else if (!RTStrICmp(ValueUnion.psz, "dvd")) + { + CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD)); + } + else if (!RTStrICmp(ValueUnion.psz, "disk")) + { + CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk)); + } + else if (!RTStrICmp(ValueUnion.psz, "net")) + { + CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Network)); + } + else + return errorArgument("Invalid boot device '%s'", ValueUnion.psz); + break; + } + + case MODIFYVM_HDA: // deprecated + case MODIFYVM_HDB: // deprecated + case MODIFYVM_HDD: // deprecated + case MODIFYVM_SATAPORT: // deprecated + { + uint32_t u1 = 0, u2 = 0; + Bstr bstrController = L"IDE Controller"; + + switch (c) + { + case MODIFYVM_HDA: // deprecated + u1 = 0; + break; + + case MODIFYVM_HDB: // deprecated + u1 = 0; + u2 = 1; + break; + + case MODIFYVM_HDD: // deprecated + u1 = 1; + u2 = 1; + break; + + case MODIFYVM_SATAPORT: // deprecated + u1 = GetOptState.uIndex; + bstrController = L"SATA"; + break; + } + + if (!RTStrICmp(ValueUnion.psz, "none")) + { + sessionMachine->DetachDevice(bstrController.raw(), u1, u2); + } + else + { + ComPtr<IMedium> hardDisk; + rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk, + AccessMode_ReadWrite, hardDisk, + false /* fForceNewUuidOnOpen */, + false /* fSilent */); + if (FAILED(rc)) + break; + if (hardDisk) + { + CHECK_ERROR(sessionMachine, AttachDevice(bstrController.raw(), + u1, u2, + DeviceType_HardDisk, + hardDisk)); + } + else + rc = E_FAIL; + } + break; + } + + case MODIFYVM_IDECONTROLLER: // deprecated + { + ComPtr<IStorageController> storageController; + CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("IDE Controller").raw(), + storageController.asOutParam())); + + if (!RTStrICmp(ValueUnion.psz, "PIIX3")) + { + CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3)); + } + else if (!RTStrICmp(ValueUnion.psz, "PIIX4")) + { + CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4)); + } + else if (!RTStrICmp(ValueUnion.psz, "ICH6")) + { + CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6)); + } + else + { + errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_SATAPORTCOUNT: // deprecated + { + ComPtr<IStorageController> SataCtl; + CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("SATA").raw(), + SataCtl.asOutParam())); + + if (SUCCEEDED(rc) && ValueUnion.u32 > 0) + CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32)); + break; + } + + case MODIFYVM_SATA: // deprecated + { + if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable")) + { + ComPtr<IStorageController> ctl; + CHECK_ERROR(sessionMachine, AddStorageController(Bstr("SATA").raw(), + StorageBus_SATA, + ctl.asOutParam())); + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci)); + } + else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable")) + CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw())); + else + return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz); + break; + } + + case MODIFYVM_SCSIPORT: // deprecated + { + if (!RTStrICmp(ValueUnion.psz, "none")) + { + rc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(), + GetOptState.uIndex, 0); + if (FAILED(rc)) + CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(), + GetOptState.uIndex, 0)); + } + else + { + ComPtr<IMedium> hardDisk; + rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk, + AccessMode_ReadWrite, hardDisk, + false /* fForceNewUuidOnOpen */, + false /* fSilent */); + if (FAILED(rc)) + break; + if (hardDisk) + { + rc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(), + GetOptState.uIndex, 0, + DeviceType_HardDisk, + hardDisk); + if (FAILED(rc)) + CHECK_ERROR(sessionMachine, + AttachDevice(Bstr("BusLogic").raw(), + GetOptState.uIndex, 0, + DeviceType_HardDisk, + hardDisk)); + } + else + rc = E_FAIL; + } + break; + } + + case MODIFYVM_SCSITYPE: // deprecated + { + ComPtr<IStorageController> ctl; + + if (!RTStrICmp(ValueUnion.psz, "LsiLogic")) + { + rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw()); + if (FAILED(rc)) + CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw())); + + CHECK_ERROR(sessionMachine, + AddStorageController(Bstr("LsiLogic").raw(), + StorageBus_SCSI, + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic)); + } + else if (!RTStrICmp(ValueUnion.psz, "BusLogic")) + { + rc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw()); + if (FAILED(rc)) + CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw())); + + CHECK_ERROR(sessionMachine, + AddStorageController(Bstr("BusLogic").raw(), + StorageBus_SCSI, + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic)); + } + else + return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz); + break; + } + + case MODIFYVM_SCSI: // deprecated + { + if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable")) + { + ComPtr<IStorageController> ctl; + + CHECK_ERROR(sessionMachine, AddStorageController(Bstr("BusLogic").raw(), + StorageBus_SCSI, + ctl.asOutParam())); + if (SUCCEEDED(rc)) + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic)); + } + else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable")) + { + rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw()); + if (FAILED(rc)) + CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw())); + } + break; + } + + case MODIFYVM_DVDPASSTHROUGH: // deprecated + { + CHECK_ERROR(sessionMachine, PassthroughDevice(Bstr("IDE Controller").raw(), + 1, 0, + !RTStrICmp(ValueUnion.psz, "on"))); + break; + } + + case MODIFYVM_DVD: // deprecated + { + ComPtr<IMedium> dvdMedium; + + /* unmount? */ + if (!RTStrICmp(ValueUnion.psz, "none")) + { + /* nothing to do, NULL object will cause unmount */ + } + /* host drive? */ + else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:"))) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(), + dvdMedium.asOutParam()); + if (!dvdMedium) + { + /* 2nd try: try with the real name, important on Linux+libhal */ + char szPathReal[RTPATH_MAX]; + if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal)))) + { + errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5); + rc = E_FAIL; + break; + } + rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(), + dvdMedium.asOutParam()); + if (!dvdMedium) + { + errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5); + rc = E_FAIL; + break; + } + } + } + else + { + rc = openMedium(a, ValueUnion.psz, DeviceType_DVD, + AccessMode_ReadOnly, dvdMedium, + false /* fForceNewUuidOnOpen */, + false /* fSilent */); + if (FAILED(rc)) + break; + if (!dvdMedium) + { + rc = E_FAIL; + break; + } + } + + CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller").raw(), + 1, 0, + dvdMedium, + FALSE /* aForce */)); + break; + } + + case MODIFYVM_FLOPPY: // deprecated + { + ComPtr<IMedium> floppyMedium; + ComPtr<IMediumAttachment> floppyAttachment; + sessionMachine->GetMediumAttachment(Bstr("Floppy Controller").raw(), + 0, 0, floppyAttachment.asOutParam()); + + /* disable? */ + if (!RTStrICmp(ValueUnion.psz, "disabled")) + { + /* disable the controller */ + if (floppyAttachment) + CHECK_ERROR(sessionMachine, DetachDevice(Bstr("Floppy Controller").raw(), + 0, 0)); + } + else + { + /* enable the controller */ + if (!floppyAttachment) + CHECK_ERROR(sessionMachine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(), + 0, 0, + DeviceType_Floppy)); + + /* unmount? */ + if ( !RTStrICmp(ValueUnion.psz, "none") + || !RTStrICmp(ValueUnion.psz, "empty")) // deprecated + { + /* nothing to do, NULL object will cause unmount */ + } + /* host drive? */ + else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:"))) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(), + floppyMedium.asOutParam()); + if (!floppyMedium) + { + errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5); + rc = E_FAIL; + break; + } + } + else + { + rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy, + AccessMode_ReadWrite, floppyMedium, + false /* fForceNewUuidOnOpen */, + false /* fSilent */); + if (FAILED(rc)) + break; + if (!floppyMedium) + { + rc = E_FAIL; + break; + } + } + CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller").raw(), + 0, 0, + floppyMedium, + FALSE /* aForce */)); + } + break; + } + + case MODIFYVM_NICTRACEFILE: + { + + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_NICTRACE: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_NICPROPERTY: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + if (nic) + { + /* Parse 'name=value' */ + char *pszProperty = RTStrDup(ValueUnion.psz); + if (pszProperty) + { + char *pDelimiter = strchr(pszProperty, '='); + if (pDelimiter) + { + *pDelimiter = '\0'; + + Bstr bstrName = pszProperty; + Bstr bstrValue = &pDelimiter[1]; + CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw())); + } + else + { + errorArgument("Invalid --nicproperty%d argument '%s'", GetOptState.uIndex, ValueUnion.psz); + rc = E_FAIL; + } + RTStrFree(pszProperty); + } + else + { + RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for --nicproperty%d '%s'\n", GetOptState.uIndex, ValueUnion.psz); + rc = E_FAIL; + } + } + break; + } + case MODIFYVM_NICTYPE: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + if (!RTStrICmp(ValueUnion.psz, "Am79C970A")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A)); + } + else if (!RTStrICmp(ValueUnion.psz, "Am79C973")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973)); + } +#ifdef VBOX_WITH_E1000 + else if (!RTStrICmp(ValueUnion.psz, "82540EM")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM)); + } + else if (!RTStrICmp(ValueUnion.psz, "82543GC")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC)); + } + else if (!RTStrICmp(ValueUnion.psz, "82545EM")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM)); + } +#endif +#ifdef VBOX_WITH_VIRTIO + else if (!RTStrICmp(ValueUnion.psz, "virtio")) + { + CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio)); + } +#endif /* VBOX_WITH_VIRTIO */ + else + { + errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_NICSPEED: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32)); + break; + } + + case MODIFYVM_NICBOOTPRIO: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + /* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices + * to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to + * 0 for the default lowest priority). + */ + if (ValueUnion.u32 > 4) + { + errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex); + rc = E_FAIL; + } + else + { + CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32)); + } + break; + } + + case MODIFYVM_NICPROMISC: + { + NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy; + if (!RTStrICmp(ValueUnion.psz, "deny")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny; + else if ( !RTStrICmp(ValueUnion.psz, "allow-vms") + || !RTStrICmp(ValueUnion.psz, "allow-network")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork; + else if (!RTStrICmp(ValueUnion.psz, "allow-all")) + enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll; + else + { + errorArgument("Unknown promiscuous mode policy '%s'", ValueUnion.psz); + rc = E_INVALIDARG; + break; + } + + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy)); + break; + } + + case MODIFYVM_NICBWGROUP: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + if (!RTStrICmp(ValueUnion.psz, "none")) + { + /* Just remove the bandwidth group. */ + CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL)); + } + else + { + ComPtr<IBandwidthControl> bwCtrl; + ComPtr<IBandwidthGroup> bwGroup; + + CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam())); + + if (SUCCEEDED(rc)) + { + CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam())); + if (SUCCEEDED(rc)) + { + CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup)); + } + } + } + break; + } + + case MODIFYVM_NIC: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE)); + } + else if (!RTStrICmp(ValueUnion.psz, "null")) + { + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null)); + } + else if (!RTStrICmp(ValueUnion.psz, "nat")) + { + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT)); + } + else if ( !RTStrICmp(ValueUnion.psz, "bridged") + || !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */ + { + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged)); + } + else if (!RTStrICmp(ValueUnion.psz, "intnet")) + { + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal)); + } + else if (!RTStrICmp(ValueUnion.psz, "hostonly")) + { + + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly)); + } + else if (!RTStrICmp(ValueUnion.psz, "generic")) + { + + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic)); + } + else if (!RTStrICmp(ValueUnion.psz, "natnetwork")) + { + + CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE)); + CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork)); + } + else + { + errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_CABLECONNECTED: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f)); + break; + } + + case MODIFYVM_BRIDGEADAPTER: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + /* remove it? */ + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw())); + } + else + { + CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw())); + } + break; + } + + case MODIFYVM_HOSTONLYADAPTER: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + /* remove it? */ + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw())); + } + else + { + CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw())); + } + break; + } + + case MODIFYVM_INTNET: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + /* remove it? */ + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw())); + } + else + { + CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw())); + } + break; + } + + case MODIFYVM_GENERICDRV: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_NATNETWORKNAME: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_NATNET: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + const char *psz = ValueUnion.psz; + if (!RTStrICmp("default", psz)) + psz = ""; + + CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw())); + break; + } + + case MODIFYVM_NATBINDIP: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw())); + break; + } + +#define ITERATE_TO_NEXT_TERM(ch) \ + do { \ + while (*ch != ',') \ + { \ + if (*ch == 0) \ + { \ + return errorSyntax(USAGE_MODIFYVM, \ + "Missing or Invalid argument to '%s'", \ + GetOptState.pDef->pszLong); \ + } \ + ch++; \ + } \ + *ch = '\0'; \ + ch++; \ + } while(0) + + case MODIFYVM_NATSETTINGS: + { + ComPtr<INetworkAdapter> nic; + ComPtr<INATEngine> engine; + char *strMtu; + char *strSockSnd; + char *strSockRcv; + char *strTcpSnd; + char *strTcpRcv; + char *strRaw = RTStrDup(ValueUnion.psz); + char *ch = strRaw; + strMtu = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strSockSnd = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strSockRcv = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strTcpSnd = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strTcpRcv = RTStrStrip(ch); + + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv), + RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv))); + break; + } + + + case MODIFYVM_NATPF: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + /* format name:proto:hostip:hostport:guestip:guestport*/ + if (RTStrCmp(ValueUnion.psz, "delete") != 0) + { + char *strName; + char *strProto; + char *strHostIp; + char *strHostPort; + char *strGuestIp; + char *strGuestPort; + char *strRaw = RTStrDup(ValueUnion.psz); + char *ch = strRaw; + strName = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strProto = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strHostIp = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strHostPort = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strGuestIp = RTStrStrip(ch); + ITERATE_TO_NEXT_TERM(ch); + strGuestPort = RTStrStrip(ch); + NATProtocol_T proto; + if (RTStrICmp(strProto, "udp") == 0) + proto = NATProtocol_UDP; + else if (RTStrICmp(strProto, "tcp") == 0) + proto = NATProtocol_TCP; + else + { + errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex); + rc = E_FAIL; + break; + } + CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto, + Bstr(strHostIp).raw(), + RTStrToUInt16(strHostPort), + Bstr(strGuestIp).raw(), + RTStrToUInt16(strGuestPort))); + } + else + { + /* delete NAT Rule operation */ + int vrc; + vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, "Not enough parameters"); + CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw())); + } + break; + } + #undef ITERATE_TO_NEXT_TERM + case MODIFYVM_NATALIASMODE: + { + ComPtr<INetworkAdapter> nic; + ComPtr<INATEngine> engine; + uint32_t aliasMode = 0; + + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + if (RTStrCmp(ValueUnion.psz, "default") == 0) + aliasMode = 0; + else + { + char *token = (char *)ValueUnion.psz; + while (token) + { + if (RTStrNCmp(token, RT_STR_TUPLE("log")) == 0) + aliasMode |= NATAliasMode_AliasLog; + else if (RTStrNCmp(token, RT_STR_TUPLE("proxyonly")) == 0) + aliasMode |= NATAliasMode_AliasProxyOnly; + else if (RTStrNCmp(token, RT_STR_TUPLE("sameports")) == 0) + aliasMode |= NATAliasMode_AliasUseSamePorts; + token = RTStrStr(token, ","); + if (token == NULL) + break; + token++; + } + } + CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode)); + break; + } + + case MODIFYVM_NATTFTPPREFIX: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_NATTFTPFILE: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_NATTFTPSERVER: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw())); + break; + } + case MODIFYVM_NATDNSPASSDOMAIN: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f)); + break; + } + + case MODIFYVM_NATDNSPROXY: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f)); + break; + } + + case MODIFYVM_NATDNSHOSTRESOLVER: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + ComPtr<INATEngine> engine; + CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam())); + + CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f)); + break; + } + case MODIFYVM_MACADDRESS: + { + if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC")) + break; + + ComPtr<INetworkAdapter> nic; + CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam())); + ASSERT(nic); + + /* generate one? */ + if (!RTStrICmp(ValueUnion.psz, "auto")) + { + CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw())); + } + else + { + CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw())); + } + break; + } + + case MODIFYVM_HIDPTR: + { + bool fEnableUsb = false; + if (!RTStrICmp(ValueUnion.psz, "ps2")) + { + CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse)); + } + else if (!RTStrICmp(ValueUnion.psz, "usb")) + { + CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse)); + if (SUCCEEDED(rc)) + fEnableUsb = true; + } + else if (!RTStrICmp(ValueUnion.psz, "usbtablet")) + { + CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet)); + if (SUCCEEDED(rc)) + fEnableUsb = true; + } + else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch")) + { + CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch)); + if (SUCCEEDED(rc)) + fEnableUsb = true; + } + else + { + errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz); + rc = E_FAIL; + } + if (fEnableUsb) + { + /* Make sure either the OHCI or xHCI controller is enabled. */ + ULONG cOhciCtrls = 0; + ULONG cXhciCtrls = 0; + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls); + if (SUCCEEDED(rc)) { + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls); + if ( SUCCEEDED(rc) + && cOhciCtrls + cXhciCtrls == 0) + { + /* If there's nothing, enable OHCI (always available). */ + ComPtr<IUSBController> UsbCtl; + CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, + UsbCtl.asOutParam())); + } + } + } + break; + } + + case MODIFYVM_HIDKBD: + { + bool fEnableUsb = false; + if (!RTStrICmp(ValueUnion.psz, "ps2")) + { + CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard)); + } + else if (!RTStrICmp(ValueUnion.psz, "usb")) + { + CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard)); + if (SUCCEEDED(rc)) + fEnableUsb = true; + } + else + { + errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz); + rc = E_FAIL; + } + if (fEnableUsb) + { + /* Make sure either the OHCI or xHCI controller is enabled. */ + ULONG cOhciCtrls = 0; + ULONG cXhciCtrls = 0; + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls); + if (SUCCEEDED(rc)) { + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls); + if ( SUCCEEDED(rc) + && cOhciCtrls + cXhciCtrls == 0) + { + /* If there's nothing, enable OHCI (always available). */ + ComPtr<IUSBController> UsbCtl; + CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, + UsbCtl.asOutParam())); + } + } + } + break; + } + + case MODIFYVM_UARTMODE: + { + ComPtr<ISerialPort> uart; + + CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam())); + ASSERT(uart); + + if (!RTStrICmp(ValueUnion.psz, "disconnected")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected)); + } + else if ( !RTStrICmp(ValueUnion.psz, "server") + || !RTStrICmp(ValueUnion.psz, "client") + || !RTStrICmp(ValueUnion.psz, "tcpserver") + || !RTStrICmp(ValueUnion.psz, "tcpclient") + || !RTStrICmp(ValueUnion.psz, "file")) + { + const char *pszMode = ValueUnion.psz; + + int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, + "Missing or Invalid argument to '%s'", + GetOptState.pDef->pszLong); + + CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw())); + + if (!RTStrICmp(pszMode, "server")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe)); + CHECK_ERROR(uart, COMSETTER(Server)(TRUE)); + } + else if (!RTStrICmp(pszMode, "client")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe)); + CHECK_ERROR(uart, COMSETTER(Server)(FALSE)); + } + else if (!RTStrICmp(pszMode, "tcpserver")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP)); + CHECK_ERROR(uart, COMSETTER(Server)(TRUE)); + } + else if (!RTStrICmp(pszMode, "tcpclient")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP)); + CHECK_ERROR(uart, COMSETTER(Server)(FALSE)); + } + else if (!RTStrICmp(pszMode, "file")) + { + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile)); + } + } + else + { + CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw())); + CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice)); + } + break; + } + + case MODIFYVM_UARTTYPE: + { + ComPtr<ISerialPort> uart; + + CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam())); + ASSERT(uart); + + if (!RTStrICmp(ValueUnion.psz, "16450")) + { + CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16450)); + } + else if (!RTStrICmp(ValueUnion.psz, "16550A")) + { + CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16550A)); + } + else if (!RTStrICmp(ValueUnion.psz, "16750")) + { + CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16750)); + } + else + return errorSyntax(USAGE_MODIFYVM, + "Invalid argument to '%s'", + GetOptState.pDef->pszLong); + break; + } + + case MODIFYVM_UART: + { + ComPtr<ISerialPort> uart; + + CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam())); + ASSERT(uart); + + if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable")) + CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE)); + else + { + const char *pszIOBase = ValueUnion.psz; + uint32_t uVal = 0; + + int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART; + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, + "Missing or Invalid argument to '%s'", + GetOptState.pDef->pszLong); + + CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32)); + + vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal); + if (vrc != VINF_SUCCESS || uVal == 0) + return errorArgument("Error parsing UART I/O base '%s'", pszIOBase); + CHECK_ERROR(uart, COMSETTER(IOBase)(uVal)); + + CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE)); + } + break; + } + +#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS) + case MODIFYVM_LPTMODE: + { + ComPtr<IParallelPort> lpt; + + CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam())); + ASSERT(lpt); + + CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_LPT: + { + ComPtr<IParallelPort> lpt; + + CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam())); + ASSERT(lpt); + + if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable")) + CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE)); + else + { + const char *pszIOBase = ValueUnion.psz; + uint32_t uVal = 0; + + int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT; + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, + "Missing or Invalid argument to '%s'", + GetOptState.pDef->pszLong); + + CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32)); + + vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal); + if (vrc != VINF_SUCCESS || uVal == 0) + return errorArgument("Error parsing LPT I/O base '%s'", pszIOBase); + CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal)); + + CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE)); + } + break; + } +#endif + + case MODIFYVM_GUESTMEMORYBALLOON: + { + CHECK_ERROR(sessionMachine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32)); + break; + } + + case MODIFYVM_AUDIOCONTROLLER: + { + ComPtr<IAudioAdapter> audioAdapter; + sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); + ASSERT(audioAdapter); + + if (!RTStrICmp(ValueUnion.psz, "sb16")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16)); + else if (!RTStrICmp(ValueUnion.psz, "ac97")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97)); + else if (!RTStrICmp(ValueUnion.psz, "hda")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA)); + else + { + errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_AUDIOCODEC: + { + ComPtr<IAudioAdapter> audioAdapter; + sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); + ASSERT(audioAdapter); + + if (!RTStrICmp(ValueUnion.psz, "sb16")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_SB16)); + else if (!RTStrICmp(ValueUnion.psz, "stac9700")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9700)); + else if (!RTStrICmp(ValueUnion.psz, "ad1980")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_AD1980)); + else if (!RTStrICmp(ValueUnion.psz, "stac9221")) + CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9221)); + else + { + errorArgument("Invalid --audiocodec argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_AUDIO: + { + ComPtr<IAudioAdapter> audioAdapter; + sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); + ASSERT(audioAdapter); + + /* disable? */ + if (!RTStrICmp(ValueUnion.psz, "none")) + { + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false)); + } + else if (!RTStrICmp(ValueUnion.psz, "null")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#ifdef RT_OS_WINDOWS +#ifdef VBOX_WITH_WINMM + else if (!RTStrICmp(ValueUnion.psz, "winmm")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif + else if (!RTStrICmp(ValueUnion.psz, "dsound")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif /* RT_OS_WINDOWS */ +#ifdef VBOX_WITH_AUDIO_OSS + else if (!RTStrICmp(ValueUnion.psz, "oss")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif +#ifdef VBOX_WITH_AUDIO_ALSA + else if (!RTStrICmp(ValueUnion.psz, "alsa")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif +#ifdef VBOX_WITH_AUDIO_PULSE + else if (!RTStrICmp(ValueUnion.psz, "pulse")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif +#ifdef RT_OS_DARWIN + else if (!RTStrICmp(ValueUnion.psz, "coreaudio")) + { + CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio)); + CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true)); + } +#endif /* !RT_OS_DARWIN */ + else + { + errorArgument("Invalid --audio argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_AUDIOIN: + { + ComPtr<IAudioAdapter> audioAdapter; + sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); + ASSERT(audioAdapter); + + CHECK_ERROR(audioAdapter, COMSETTER(EnabledIn)(ValueUnion.f)); + break; + } + + case MODIFYVM_AUDIOOUT: + { + ComPtr<IAudioAdapter> audioAdapter; + sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam()); + ASSERT(audioAdapter); + + CHECK_ERROR(audioAdapter, COMSETTER(EnabledOut)(ValueUnion.f)); + break; + } + + case MODIFYVM_CLIPBOARD: + { + ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */ + if (!RTStrICmp(ValueUnion.psz, "disabled")) + mode = ClipboardMode_Disabled; + else if (!RTStrICmp(ValueUnion.psz, "hosttoguest")) + mode = ClipboardMode_HostToGuest; + else if (!RTStrICmp(ValueUnion.psz, "guesttohost")) + mode = ClipboardMode_GuestToHost; + else if (!RTStrICmp(ValueUnion.psz, "bidirectional")) + mode = ClipboardMode_Bidirectional; + else + { + errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + if (SUCCEEDED(rc)) + { + CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode)); + } + break; + } + + case MODIFYVM_DRAGANDDROP: + { + DnDMode_T mode = DnDMode_Disabled; /* Shut up MSC */ + if (!RTStrICmp(ValueUnion.psz, "disabled")) + mode = DnDMode_Disabled; + else if (!RTStrICmp(ValueUnion.psz, "hosttoguest")) + mode = DnDMode_HostToGuest; + else if (!RTStrICmp(ValueUnion.psz, "guesttohost")) + mode = DnDMode_GuestToHost; + else if (!RTStrICmp(ValueUnion.psz, "bidirectional")) + mode = DnDMode_Bidirectional; + else + { + errorArgument("Invalid --draganddrop argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + if (SUCCEEDED(rc)) + { + CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode)); + } + break; + } + + case MODIFYVM_VRDE_EXTPACK: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + if (vrdeServer) + { + if (RTStrICmp(ValueUnion.psz, "default") != 0) + { + Bstr bstr(ValueUnion.psz); + CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw())); + } + else + CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw())); + } + break; + } + + case MODIFYVM_VRDEPROPERTY: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + if (vrdeServer) + { + /* Parse 'name=value' */ + char *pszProperty = RTStrDup(ValueUnion.psz); + if (pszProperty) + { + char *pDelimiter = strchr(pszProperty, '='); + if (pDelimiter) + { + *pDelimiter = '\0'; + + Bstr bstrName = pszProperty; + Bstr bstrValue = &pDelimiter[1]; + CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw())); + } + else + { + RTStrFree(pszProperty); + + errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz); + rc = E_FAIL; + break; + } + RTStrFree(pszProperty); + } + else + { + RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", ValueUnion.psz); + rc = E_FAIL; + } + } + break; + } + + case MODIFYVM_VRDPPORT: + vrdeWarningDeprecatedOption("port"); + RT_FALL_THRU(); + + case MODIFYVM_VRDEPORT: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + if (!RTStrICmp(ValueUnion.psz, "default")) + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw())); + else + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_VRDPADDRESS: + vrdeWarningDeprecatedOption("address"); + RT_FALL_THRU(); + + case MODIFYVM_VRDEADDRESS: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_VRDPAUTHTYPE: + vrdeWarningDeprecatedOption("authtype"); + RT_FALL_THRU(); + case MODIFYVM_VRDEAUTHTYPE: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + if (!RTStrICmp(ValueUnion.psz, "null")) + { + CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null)); + } + else if (!RTStrICmp(ValueUnion.psz, "external")) + { + CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External)); + } + else if (!RTStrICmp(ValueUnion.psz, "guest")) + { + CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest)); + } + else + { + errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_VRDEAUTHLIBRARY: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + if (vrdeServer) + { + if (RTStrICmp(ValueUnion.psz, "default") != 0) + { + Bstr bstr(ValueUnion.psz); + CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw())); + } + else + CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw())); + } + break; + } + + case MODIFYVM_VRDPMULTICON: + vrdeWarningDeprecatedOption("multicon"); + RT_FALL_THRU(); + case MODIFYVM_VRDEMULTICON: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f)); + break; + } + + case MODIFYVM_VRDPREUSECON: + vrdeWarningDeprecatedOption("reusecon"); + RT_FALL_THRU(); + case MODIFYVM_VRDEREUSECON: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f)); + break; + } + + case MODIFYVM_VRDPVIDEOCHANNEL: + vrdeWarningDeprecatedOption("videochannel"); + RT_FALL_THRU(); + case MODIFYVM_VRDEVIDEOCHANNEL: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(), + ValueUnion.f? Bstr("true").raw(): Bstr("false").raw())); + break; + } + + case MODIFYVM_VRDPVIDEOCHANNELQUALITY: + vrdeWarningDeprecatedOption("videochannelquality"); + RT_FALL_THRU(); + case MODIFYVM_VRDEVIDEOCHANNELQUALITY: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(), + Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_VRDP: + vrdeWarningDeprecatedOption(""); + RT_FALL_THRU(); + case MODIFYVM_VRDE: + { + ComPtr<IVRDEServer> vrdeServer; + sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam()); + ASSERT(vrdeServer); + + CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_USBRENAME: + { + const char *pszName = ValueUnion.psz; + int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_MODIFYVM, + "Missing or Invalid argument to '%s'", + GetOptState.pDef->pszLong); + const char *pszNewName = ValueUnion.psz; + + SafeIfaceArray<IUSBController> ctrls; + CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls))); + bool fRenamed = false; + for (size_t i = 0; i < ctrls.size(); i++) + { + ComPtr<IUSBController> pCtrl = ctrls[i]; + Bstr bstrName; + CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam())); + if (bstrName == pszName) + { + bstrName = pszNewName; + CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw())); + fRenamed = true; + } + } + if (!fRenamed) + { + errorArgument("Invalid --usbrename parameters, nothing renamed"); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_USBXHCI: + { + ULONG cXhciCtrls = 0; + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls); + if (SUCCEEDED(rc)) + { + if (!cXhciCtrls && ValueUnion.f) + { + ComPtr<IUSBController> UsbCtl; + CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI, + UsbCtl.asOutParam())); + } + else if (cXhciCtrls && !ValueUnion.f) + { + SafeIfaceArray<IUSBController> ctrls; + CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls))); + for (size_t i = 0; i < ctrls.size(); i++) + { + ComPtr<IUSBController> pCtrl = ctrls[i]; + USBControllerType_T enmType; + CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType)); + if (enmType == USBControllerType_XHCI) + { + Bstr ctrlName; + CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam())); + CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw())); + } + } + } + } + break; + } + + case MODIFYVM_USBEHCI: + { + ULONG cEhciCtrls = 0; + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls); + if (SUCCEEDED(rc)) + { + if (!cEhciCtrls && ValueUnion.f) + { + ComPtr<IUSBController> UsbCtl; + CHECK_ERROR(sessionMachine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI, + UsbCtl.asOutParam())); + } + else if (cEhciCtrls && !ValueUnion.f) + { + SafeIfaceArray<IUSBController> ctrls; + CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls))); + for (size_t i = 0; i < ctrls.size(); i++) + { + ComPtr<IUSBController> pCtrl = ctrls[i]; + USBControllerType_T enmType; + CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType)); + if (enmType == USBControllerType_EHCI) + { + Bstr ctrlName; + CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam())); + CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw())); + } + } + } + } + break; + } + + case MODIFYVM_USBOHCI: + { + ULONG cOhciCtrls = 0; + rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls); + if (SUCCEEDED(rc)) + { + if (!cOhciCtrls && ValueUnion.f) + { + ComPtr<IUSBController> UsbCtl; + CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI, + UsbCtl.asOutParam())); + } + else if (cOhciCtrls && !ValueUnion.f) + { + SafeIfaceArray<IUSBController> ctrls; + CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls))); + for (size_t i = 0; i < ctrls.size(); i++) + { + ComPtr<IUSBController> pCtrl = ctrls[i]; + USBControllerType_T enmType; + CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType)); + if (enmType == USBControllerType_OHCI) + { + Bstr ctrlName; + CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam())); + CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw())); + } + } + } + } + break; + } + + case MODIFYVM_SNAPSHOTFOLDER: + { + if (!RTStrICmp(ValueUnion.psz, "default")) + CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr().raw())); + else + CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_TELEPORTER_ENABLED: + { + CHECK_ERROR(sessionMachine, COMSETTER(TeleporterEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_TELEPORTER_PORT: + { + CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPort)(ValueUnion.u32)); + break; + } + + case MODIFYVM_TELEPORTER_ADDRESS: + { + CHECK_ERROR(sessionMachine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_TELEPORTER_PASSWORD: + { + CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_TELEPORTER_PASSWORD_FILE: + { + Utf8Str password; + RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password); + if (rcExit != RTEXITCODE_SUCCESS) + rc = E_FAIL; + else + CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw())); + break; + } + + case MODIFYVM_TRACING_ENABLED: + { + CHECK_ERROR(sessionMachine, COMSETTER(TracingEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_TRACING_CONFIG: + { + CHECK_ERROR(sessionMachine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_TRACING_ALLOW_VM_ACCESS: + { + CHECK_ERROR(sessionMachine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f)); + break; + } + + case MODIFYVM_FAULT_TOLERANCE: + { + if (!RTStrICmp(ValueUnion.psz, "master")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Master))); + } + else + if (!RTStrICmp(ValueUnion.psz, "standby")) + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Standby))); + } + else + { + errorArgument("Invalid --faulttolerance argument '%s'", ValueUnion.psz); + rc = E_FAIL; + } + break; + } + + case MODIFYVM_FAULT_TOLERANCE_ADDRESS: + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_FAULT_TOLERANCE_PORT: + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePort)(ValueUnion.u32)); + break; + } + + case MODIFYVM_FAULT_TOLERANCE_PASSWORD: + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL: + { + CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32)); + break; + } + + case MODIFYVM_HARDWARE_UUID: + { + CHECK_ERROR(sessionMachine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw())); + break; + } + + case MODIFYVM_HPET: + { + CHECK_ERROR(sessionMachine, COMSETTER(HPETEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_IOCACHE: + { + CHECK_ERROR(sessionMachine, COMSETTER(IOCacheEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_IOCACHESIZE: + { + CHECK_ERROR(sessionMachine, COMSETTER(IOCacheSize)(ValueUnion.u32)); + break; + } + + case MODIFYVM_CHIPSET: + { + if (!RTStrICmp(ValueUnion.psz, "piix3")) + { + CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_PIIX3)); + } + else if (!RTStrICmp(ValueUnion.psz, "ich9")) + { + CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_ICH9)); + BOOL fIoApic = FALSE; + CHECK_ERROR(biosSettings, COMGETTER(IOAPICEnabled)(&fIoApic)); + if (!fIoApic) + { + RTStrmPrintf(g_pStdErr, "*** I/O APIC must be enabled for ICH9, enabling. ***\n"); + CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE)); + } + } + else + { + errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz); + rc = E_FAIL; + } + break; + } +#ifdef VBOX_WITH_RECORDING + case MODIFYVM_RECORDING: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_SCREENS: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_FILENAME: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_VIDEO_WIDTH: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_VIDEO_HEIGHT: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_VIDEO_RES: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_VIDEO_RATE: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_VIDEO_FPS: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_MAXTIME: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_MAXSIZE: + RT_FALL_THROUGH(); + case MODIFYVM_RECORDING_OPTIONS: + { + ComPtr<IRecordingSettings> recordingSettings; + CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam())); + SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens; + CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens))); + + switch (c) + { + case MODIFYVM_RECORDING: + { + CHECK_ERROR(recordingSettings, COMSETTER(Enabled)(ValueUnion.f)); + break; + } + case MODIFYVM_RECORDING_SCREENS: + { + ULONG cMonitors = 64; + CHECK_ERROR(sessionMachine, COMGETTER(MonitorCount)(&cMonitors)); + com::SafeArray<BOOL> screens(cMonitors); + if (parseScreens(ValueUnion.psz, &screens)) + { + errorArgument("Invalid list of screens specified\n"); + rc = E_FAIL; + break; + } + + if (cMonitors > saRecordingScreenScreens.size()) /* Paranoia. */ + cMonitors = (ULONG)saRecordingScreenScreens.size(); + + for (size_t i = 0; i < cMonitors; ++i) + CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(screens[i])); + break; + } + case MODIFYVM_RECORDING_FILENAME: + { + Bstr bstr; + /* empty string will fall through, leaving bstr empty */ + if (*ValueUnion.psz) + { + char szVCFileAbs[RTPATH_MAX] = ""; + int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs)); + if (RT_FAILURE(vrc)) + { + errorArgument("Cannot convert filename \"%s\" to absolute path\n", ValueUnion.psz); + rc = E_FAIL; + break; + } + bstr = szVCFileAbs; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Filename)(bstr.raw())); + break; + } + case MODIFYVM_RECORDING_VIDEO_WIDTH: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_VIDEO_HEIGHT: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_VIDEO_RES: + { + uint32_t uWidth = 0; + char *pszNext; + int vrc = RTStrToUInt32Ex(ValueUnion.psz, &pszNext, 0, &uWidth); + if (RT_FAILURE(vrc) || vrc != VWRN_TRAILING_CHARS || !pszNext || *pszNext != 'x') + { + errorArgument("Error parsing video resolution '%s' (expected <width>x<height>)", ValueUnion.psz); + rc = E_FAIL; + break; + } + uint32_t uHeight = 0; + vrc = RTStrToUInt32Ex(pszNext+1, NULL, 0, &uHeight); + if (vrc != VINF_SUCCESS) + { + errorArgument("Error parsing video resolution '%s' (expected <width>x<height>)", ValueUnion.psz); + rc = E_FAIL; + break; + } + + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + { + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth)); + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight)); + } + break; + } + case MODIFYVM_RECORDING_VIDEO_RATE: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_VIDEO_FPS: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_MAXTIME: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_MAXSIZE: + { + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32)); + break; + } + case MODIFYVM_RECORDING_OPTIONS: + { + Bstr bstr(ValueUnion.psz); + for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i) + CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Options)(bstr.raw())); + break; + } + } + + break; + } +#endif + case MODIFYVM_AUTOSTART_ENABLED: + { + CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(ValueUnion.f)); + break; + } + + case MODIFYVM_AUTOSTART_DELAY: + { + CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(ValueUnion.u32)); + break; + } + + case MODIFYVM_AUTOSTOP_TYPE: + { + AutostopType_T enmAutostopType = AutostopType_Disabled; + + if (!RTStrICmp(ValueUnion.psz, "disabled")) + enmAutostopType = AutostopType_Disabled; + else if (!RTStrICmp(ValueUnion.psz, "savestate")) + enmAutostopType = AutostopType_SaveState; + else if (!RTStrICmp(ValueUnion.psz, "poweroff")) + enmAutostopType = AutostopType_PowerOff; + else if (!RTStrICmp(ValueUnion.psz, "acpishutdown")) + enmAutostopType = AutostopType_AcpiShutdown; + else + { + errorArgument("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)", ValueUnion.psz); + rc = E_FAIL; + } + + if (SUCCEEDED(rc)) + CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType)); + break; + } +#ifdef VBOX_WITH_PCI_PASSTHROUGH + case MODIFYVM_ATTACH_PCI: + { + const char* pAt = strchr(ValueUnion.psz, '@'); + int32_t iHostAddr, iGuestAddr; + + iHostAddr = parsePci(ValueUnion.psz); + iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr; + + if (iHostAddr == -1 || iGuestAddr == -1) + { + errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz); + rc = E_FAIL; + } + else + { + CHECK_ERROR(sessionMachine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE)); + } + + break; + } + case MODIFYVM_DETACH_PCI: + { + int32_t iHostAddr; + + iHostAddr = parsePci(ValueUnion.psz); + if (iHostAddr == -1) + { + errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz); + rc = E_FAIL; + } + else + { + CHECK_ERROR(sessionMachine, DetachHostPCIDevice(iHostAddr)); + } + + break; + } +#endif + +#ifdef VBOX_WITH_USB_CARDREADER + case MODIFYVM_USBCARDREADER: + { + CHECK_ERROR(sessionMachine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f)); + break; + } +#endif /* VBOX_WITH_USB_CARDREADER */ + + case MODIFYVM_DEFAULTFRONTEND: + { + Bstr bstr(ValueUnion.psz); + if (bstr == "default") + bstr = Bstr::Empty; + CHECK_ERROR(sessionMachine, COMSETTER(DefaultFrontend)(bstr.raw())); + break; + } + + default: + { + errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion); + rc = E_FAIL; + break; + } + } + } + + /* commit changes */ + if (SUCCEEDED(rc)) + CHECK_ERROR(sessionMachine, SaveSettings()); + + /* it's important to always close sessions */ + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp new file mode 100644 index 00000000..6312bb03 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp @@ -0,0 +1,523 @@ +/* $Id: VBoxManageNATNetwork.cpp $ */ +/** @file + * VBoxManage - Implementation of NAT Network command command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#ifndef VBOX_ONLY_DOCS + +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> +#endif /* !VBOX_ONLY_DOCS */ + +#ifndef RT_OS_WINDOWS +# include <netinet/in.h> +#else +/* from <ws2ipdef.h> */ +# define INET6_ADDRSTRLEN 65 +#endif + +#define IPv6 + +#include <iprt/cdefs.h> +#include <iprt/cidr.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/net.h> +#include <iprt/getopt.h> +#include <iprt/ctype.h> + +#include <VBox/log.h> + +#include <vector> +#include <string> + +#include "VBoxManage.h" +#include "VBoxPortForwardString.h" + +#ifndef VBOX_ONLY_DOCS + +using namespace com; + +typedef enum +{ + OP_ADD = 1000, + OP_REMOVE, + OP_MODIFY, + OP_START, + OP_STOP +} OPCODE; + +typedef struct PFNAME2DELETE +{ + char szName[PF_NAMELEN]; + bool fIPv6; +} PFNAME2DELETE, *PPFNAME2DELETE; + +typedef std::vector<PFNAME2DELETE> VPF2DELETE; +typedef VPF2DELETE::const_iterator VPF2DELETEITERATOR; + +typedef std::vector<PORTFORWARDRULE> VPF2ADD; +typedef VPF2ADD::const_iterator VPF2ADDITERATOR; + +typedef std::vector<std::string> LOOPBACK2DELETEADD; +typedef LOOPBACK2DELETEADD::iterator LOOPBACK2DELETEADDITERATOR; + +static HRESULT printNATNetwork(const ComPtr<INATNetwork> &pNATNet) +{ + HRESULT rc; + + do + { + Bstr strVal; + CHECK_ERROR_BREAK(pNATNet, COMGETTER(NetworkName)(strVal.asOutParam())); + RTPrintf("Name: %ls\n", strVal.raw()); + CHECK_ERROR_BREAK(pNATNet, COMGETTER(Network)(strVal.asOutParam())); + RTPrintf("Network: %ls\n", strVal.raw()); + CHECK_ERROR_BREAK(pNATNet, COMGETTER(Gateway)(strVal.asOutParam())); + RTPrintf("Gateway: %ls\n", strVal.raw()); + BOOL fVal; + CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Enabled)(&fVal)); + RTPrintf("IPv6: %s\n", fVal ? "Yes" : "No"); + if (fVal) + { + CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Prefix)(strVal.asOutParam())); + RTPrintf("IPv6 Prefix: %s\n", strVal.raw()); + } + CHECK_ERROR_BREAK(pNATNet, COMGETTER(Enabled)(&fVal)); + RTPrintf("Enabled: %s\n", fVal ? "Yes" : "No"); + /** @todo Add more information here. */ + RTPrintf("\n"); + + } while (0); + + return rc; +} + +static RTEXITCODE handleNATList(HandlerArg *a) +{ + HRESULT rc; + + RTPrintf("NAT Networks:\n\n"); + + const char *pszFilter = NULL; + if (a->argc > 1) + pszFilter = a->argv[1]; + + size_t cFound = 0; + + com::SafeIfaceArray<INATNetwork> arrNetNets; + CHECK_ERROR(a->virtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(arrNetNets))); + for (size_t i = 0; i < arrNetNets.size(); ++i) + { + ComPtr<INATNetwork> pNATNet = arrNetNets[i]; + + if (pszFilter) + { + Bstr strVal; + CHECK_ERROR_BREAK(pNATNet, COMGETTER(NetworkName)(strVal.asOutParam())); + + Utf8Str strValUTF8 = Utf8Str(strVal); + if (!RTStrSimplePatternMatch(pszFilter, strValUTF8.c_str())) + continue; + } + + if (i > 0) + RTPrintf("\n"); + rc = printNATNetwork(pNATNet); + if (FAILED(rc)) + break; + + cFound++; + } + + if (SUCCEEDED(rc)) + RTPrintf("%zu %s found\n", cFound, cFound == 1 ? "network" : "networks"); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +static RTEXITCODE handleOp(HandlerArg *a, OPCODE enmCode) +{ + if (a->argc - 1 <= 1) + return errorSyntax(USAGE_NATNETWORK, "Not enough parameters"); + + const char *pNetName = NULL; + const char *pNetworkCidr = NULL; + int enable = -1; + int dhcp = -1; + int ipv6 = -1; + + VPF2DELETE vPfName2Delete; + VPF2ADD vPf2Add; + + LOOPBACK2DELETEADD vLoopback2Delete; + LOOPBACK2DELETEADD vLoopback2Add; + + LONG loopback6Offset = 0; /* ignore me */ + + static const RTGETOPTDEF g_aNATNetworkIPOptions[] = + { + { "--netname", 't', RTGETOPT_REQ_STRING }, + { "--network", 'n', RTGETOPT_REQ_STRING }, + { "--dhcp", 'h', RTGETOPT_REQ_BOOL }, + { "--ipv6", '6', RTGETOPT_REQ_BOOL }, + { "--enable", 'e', RTGETOPT_REQ_NOTHING }, + { "--disable", 'd', RTGETOPT_REQ_NOTHING }, + { "--port-forward-4", 'p', RTGETOPT_REQ_STRING }, + { "--port-forward-6", 'P', RTGETOPT_REQ_STRING }, + { "--loopback-4", 'l', RTGETOPT_REQ_STRING }, + { "--loopback-6", 'L', RTGETOPT_REQ_STRING }, + }; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, a->argc, a->argv, g_aNATNetworkIPOptions, + enmCode != OP_REMOVE ? RT_ELEMENTS(g_aNATNetworkIPOptions) : 4, /* we use only --netname and --ifname for remove*/ + 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case 't': // --netname + if (pNetName) + return errorSyntax(USAGE_NATNETWORK, "You can only specify --netname only once."); + pNetName = ValueUnion.psz; + break; + + case 'n': // --network + if (pNetworkCidr) + return errorSyntax(USAGE_NATNETWORK, "You can only specify --network only once."); + pNetworkCidr = ValueUnion.psz; + break; + + case 'e': // --enable + if (enable >= 0) + return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once."); + enable = 1; + break; + + case 'd': // --disable + if (enable >= 0) + return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once."); + enable = 0; + break; + + case 'h': + if (dhcp != -1) + return errorSyntax(USAGE_NATNETWORK, "You can specify --dhcp only once."); + dhcp = ValueUnion.f; + break; + + case '6': + if (ipv6 != -1) + return errorSyntax(USAGE_NATNETWORK, "You can specify --ipv6 only once."); + ipv6 = ValueUnion.f; + break; + + case 'L': /* ipv6 loopback */ + case 'l': /* ipv4 loopback */ + if (RTStrCmp(ValueUnion.psz, "delete") == 0) + { + /* deletion */ + if (enmCode != OP_MODIFY) + errorSyntax(USAGE_NATNETWORK, + "loopback couldn't be deleted on modified\n"); + if (c == 'L') + loopback6Offset = -1; + else + { + int vrc; + RTGETOPTUNION Addr2Delete; + vrc = RTGetOptFetchValue(&GetState, + &Addr2Delete, + RTGETOPT_REQ_STRING); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_NATNETWORK, + "Not enough parmaters\n"); + + vLoopback2Delete.push_back(std::string(Addr2Delete.psz)); + } + } + else + { + /* addition */ + if (c == 'L') + loopback6Offset = ValueUnion.u32; + else + vLoopback2Add.push_back(std::string(ValueUnion.psz)); + } + break; + + case 'P': /* ipv6 portforwarding*/ + case 'p': /* ipv4 portforwarding */ + { + if (RTStrCmp(ValueUnion.psz, "delete") != 0) + { + /* addition */ + /* netPfStrToPf will clean up the Pfr */ + PORTFORWARDRULE Pfr; + int irc = netPfStrToPf(ValueUnion.psz, (c == 'P'), &Pfr); + if (RT_FAILURE(irc)) + return errorSyntax(USAGE_NATNETWORK, "Invalid port-forward rule %s\n", ValueUnion.psz); + + vPf2Add.push_back(Pfr); + } + else + { + /* deletion */ + if (enmCode != OP_MODIFY) + return errorSyntax(USAGE_NATNETWORK, + "Port-forward could be deleted on modify \n"); + + RTGETOPTUNION NamePf2DeleteUnion; + int vrc = RTGetOptFetchValue(&GetState, &NamePf2DeleteUnion, RTGETOPT_REQ_STRING); + if (RT_FAILURE(vrc)) + return errorSyntax(USAGE_NATNETWORK, "Not enough parmaters\n"); + + if (strlen(NamePf2DeleteUnion.psz) > PF_NAMELEN) + return errorSyntax(USAGE_NATNETWORK, "Port-forward rule name is too long\n"); + + PFNAME2DELETE Name2Delete; + RT_ZERO(Name2Delete); + RTStrCopy(Name2Delete.szName, PF_NAMELEN, NamePf2DeleteUnion.psz); + Name2Delete.fIPv6 = (c == 'P'); + vPfName2Delete.push_back(Name2Delete); + } + break; + } + + default: + return errorGetOpt(USAGE_NATNETWORK, c, &ValueUnion); + } + } + + if (!pNetName) + return errorSyntax(USAGE_NATNETWORK, "You need to specify the --netname option"); + /* verification */ + switch (enmCode) + { + case OP_ADD: + if (!pNetworkCidr) + return errorSyntax(USAGE_NATNETWORK, "You need to specify the --network option"); + break; + case OP_MODIFY: + case OP_REMOVE: + case OP_START: + case OP_STOP: + break; + default: + AssertMsgFailedReturn(("Unknown operation (:%d)", enmCode), RTEXITCODE_FAILURE); + } + + HRESULT rc; + Bstr NetName; + NetName = Bstr(pNetName); + + ComPtr<INATNetwork> net; + rc = a->virtualBox->FindNATNetworkByName(NetName.mutableRaw(), net.asOutParam()); + if (enmCode == OP_ADD) + { + if (SUCCEEDED(rc)) + return errorArgument("NATNetwork server already exists"); + + CHECK_ERROR(a->virtualBox, CreateNATNetwork(NetName.raw(), net.asOutParam())); + if (FAILED(rc)) + return errorArgument("Failed to create the NAT network service"); + } + else if (FAILED(rc)) + return errorArgument("NATNetwork server does not exist"); + + switch (enmCode) + { + case OP_ADD: + case OP_MODIFY: + { + if (pNetworkCidr) + { + CHECK_ERROR(net, COMSETTER(Network)(Bstr(pNetworkCidr).raw())); + if (FAILED(rc)) + return errorArgument("Failed to set configuration"); + } + if (dhcp >= 0) + { + CHECK_ERROR(net, COMSETTER(NeedDhcpServer) ((BOOL)dhcp)); + if (FAILED(rc)) + return errorArgument("Failed to set configuration"); + } + + if (ipv6 >= 0) + { + CHECK_ERROR(net, COMSETTER(IPv6Enabled) ((BOOL)ipv6)); + if (FAILED(rc)) + return errorArgument("Failed to set configuration"); + } + + if (!vPfName2Delete.empty()) + { + VPF2DELETEITERATOR it; + for (it = vPfName2Delete.begin(); it != vPfName2Delete.end(); ++it) + { + CHECK_ERROR(net, RemovePortForwardRule((BOOL)(*it).fIPv6, + Bstr((*it).szName).raw())); + if (FAILED(rc)) + return errorArgument("Failed to delete pf"); + } + } + + if (!vPf2Add.empty()) + { + VPF2ADDITERATOR it; + for (it = vPf2Add.begin(); it != vPf2Add.end(); ++it) + { + NATProtocol_T proto = NATProtocol_TCP; + if ((*it).iPfrProto == IPPROTO_TCP) + proto = NATProtocol_TCP; + else if ((*it).iPfrProto == IPPROTO_UDP) + proto = NATProtocol_UDP; + else + continue; /* XXX: warning here. */ + + CHECK_ERROR(net, AddPortForwardRule((BOOL)(*it).fPfrIPv6, + Bstr((*it).szPfrName).raw(), + proto, + Bstr((*it).szPfrHostAddr).raw(), + (*it).u16PfrHostPort, + Bstr((*it).szPfrGuestAddr).raw(), + (*it).u16PfrGuestPort)); + if (FAILED(rc)) + return errorArgument("Failed to add pf"); + } + } + + if (loopback6Offset) + { + if (loopback6Offset == -1) + loopback6Offset = 0; /* deletion */ + + CHECK_ERROR_RET(net, COMSETTER(LoopbackIp6)(loopback6Offset), RTEXITCODE_FAILURE); + } + + /* addLocalMapping (hostid, offset) */ + if (!vLoopback2Add.empty()) + { + /* we're expecting stings 127.0.0.1=5 */ + LOOPBACK2DELETEADDITERATOR it; + for (it = vLoopback2Add.begin(); + it != vLoopback2Add.end(); + ++it) + { + std::string address, strOffset; + size_t pos = it->find('='); + LONG lOffset = 0; + Bstr bstrAddress; + + AssertReturn(pos != std::string::npos, errorArgument("invalid loopback string")); + + address = it->substr(0, pos); + strOffset = it->substr(pos + 1); + + lOffset = RTStrToUInt32(strOffset.c_str()); + AssertReturn(lOffset > 0, errorArgument("invalid loopback string")); + + bstrAddress = Bstr(address.c_str()); + + CHECK_ERROR_RET(net, AddLocalMapping(bstrAddress.raw(), lOffset), RTEXITCODE_FAILURE); + } + } + + if (!vLoopback2Delete.empty()) + { + /* we're expecting stings 127.0.0.1 */ + LOOPBACK2DELETEADDITERATOR it; + for (it = vLoopback2Add.begin(); + it != vLoopback2Add.end(); + ++it) + { + Bstr bstrAddress; + bstrAddress = Bstr(it->c_str()); + + CHECK_ERROR_RET(net, AddLocalMapping(bstrAddress.raw(), 0), RTEXITCODE_FAILURE); + } + } + + if (enable >= 0) + { + CHECK_ERROR(net, COMSETTER(Enabled) ((BOOL)enable)); + if (FAILED(rc)) + return errorArgument("Failed to set configuration"); + } + break; + } + case OP_REMOVE: + { + CHECK_ERROR(a->virtualBox, RemoveNATNetwork(net)); + if (FAILED(rc)) + return errorArgument("Failed to remove nat network"); + break; + } + case OP_START: + { + CHECK_ERROR(net, Start(Bstr("whatever").raw())); + if (FAILED(rc)) + return errorArgument("Failed to start network"); + break; + } + case OP_STOP: + { + CHECK_ERROR(net, Stop()); + if (FAILED(rc)) + return errorArgument("Failed to start network"); + break; + } + default:; + } + return RTEXITCODE_SUCCESS; +} + + +RTEXITCODE handleNATNetwork(HandlerArg *a) +{ + if (a->argc < 1) + return errorSyntax(USAGE_NATNETWORK, "Not enough parameters"); + + RTEXITCODE rcExit; + if (strcmp(a->argv[0], "modify") == 0) + rcExit = handleOp(a, OP_MODIFY); + else if (strcmp(a->argv[0], "add") == 0) + rcExit = handleOp(a, OP_ADD); + else if (strcmp(a->argv[0], "remove") == 0) + rcExit = handleOp(a, OP_REMOVE); + else if (strcmp(a->argv[0], "start") == 0) + rcExit = handleOp(a, OP_START); + else if (strcmp(a->argv[0], "stop") == 0) + rcExit = handleOp(a, OP_STOP); + else if (strcmp(a->argv[0], "list") == 0) + rcExit = handleNATList(a); + else + rcExit = errorSyntax(USAGE_NATNETWORK, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str()); + return rcExit; +} + +#endif /* !VBOX_ONLY_DOCS */ diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp new file mode 100644 index 00000000..61156bf2 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageSnapshot.cpp @@ -0,0 +1,641 @@ +/* $Id: VBoxManageSnapshot.cpp $ */ +/** @file + * VBoxManage - The 'snapshot' command. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> + +#include <VBox/com/VirtualBox.h> + +#include <iprt/getopt.h> +#include <iprt/stream.h> +#include <iprt/time.h> + +#include "VBoxManage.h" +using namespace com; + +/** + * Helper function used with "VBoxManage snapshot ... dump". Gets called to find the + * snapshot in the machine's snapshot tree that uses a particular diff image child of + * a medium. + * Horribly inefficient since we keep re-querying the snapshots tree for each image, + * but this is for quick debugging only. + * @param pMedium + * @param pThisSnapshot + * @param pCurrentSnapshot + * @param uMediumLevel + * @param uSnapshotLevel + * @return + */ +bool FindAndPrintSnapshotUsingMedium(ComPtr<IMedium> &pMedium, + ComPtr<ISnapshot> &pThisSnapshot, + ComPtr<ISnapshot> &pCurrentSnapshot, + uint32_t uMediumLevel, + uint32_t uSnapshotLevel) +{ + HRESULT rc; + + do + { + // get snapshot machine so we can figure out which diff image this created + ComPtr<IMachine> pSnapshotMachine; + CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Machine)(pSnapshotMachine.asOutParam())); + + // get media attachments + SafeIfaceArray<IMediumAttachment> aAttachments; + CHECK_ERROR_BREAK(pSnapshotMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments))); + + for (uint32_t i = 0; + i < aAttachments.size(); + ++i) + { + ComPtr<IMediumAttachment> pAttach(aAttachments[i]); + DeviceType_T type; + CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type)); + if (type == DeviceType_HardDisk) + { + ComPtr<IMedium> pMediumInSnapshot; + CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pMediumInSnapshot.asOutParam())); + + if (pMediumInSnapshot == pMedium) + { + // get snapshot name + Bstr bstrSnapshotName; + CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Name)(bstrSnapshotName.asOutParam())); + + RTPrintf("%*s \"%ls\"%s\n", + 50 + uSnapshotLevel * 2, "", // indent + bstrSnapshotName.raw(), + (pThisSnapshot == pCurrentSnapshot) ? " (CURSNAP)" : ""); + return true; // found + } + } + } + + // not found: then recurse into child snapshots + SafeIfaceArray<ISnapshot> aSnapshots; + CHECK_ERROR_BREAK(pThisSnapshot, COMGETTER(Children)(ComSafeArrayAsOutParam(aSnapshots))); + + for (uint32_t i = 0; + i < aSnapshots.size(); + ++i) + { + ComPtr<ISnapshot> pChild(aSnapshots[i]); + if (FindAndPrintSnapshotUsingMedium(pMedium, + pChild, + pCurrentSnapshot, + uMediumLevel, + uSnapshotLevel + 1)) + // found: + break; + } + } while (0); + + return false; +} + +/** + * Helper function used with "VBoxManage snapshot ... dump". Called from DumpSnapshot() + * for each hard disk attachment found in a virtual machine. This then writes out the + * root (base) medium for that hard disk attachment and recurses into the children + * tree of that medium, correlating it with the snapshots of the machine. + * @param pCurrentStateMedium constant, the medium listed in the current machine data (latest diff image). + * @param pMedium variant, initially the base medium, then a child of the base medium when recursing. + * @param pRootSnapshot constant, the root snapshot of the machine, if any; this then looks into the child snapshots. + * @param pCurrentSnapshot constant, the machine's current snapshot (so we can mark it in the output). + * @param uLevel variant, the recursion level for output indentation. + */ +void DumpMediumWithChildren(ComPtr<IMedium> &pCurrentStateMedium, + ComPtr<IMedium> &pMedium, + ComPtr<ISnapshot> &pRootSnapshot, + ComPtr<ISnapshot> &pCurrentSnapshot, + uint32_t uLevel) +{ + HRESULT rc; + do + { + // print this medium + Bstr bstrMediumName; + CHECK_ERROR_BREAK(pMedium, COMGETTER(Name)(bstrMediumName.asOutParam())); + RTPrintf("%*s \"%ls\"%s\n", + uLevel * 2, "", // indent + bstrMediumName.raw(), + (pCurrentStateMedium == pMedium) ? " (CURSTATE)" : ""); + + // find and print the snapshot that uses this particular medium (diff image) + FindAndPrintSnapshotUsingMedium(pMedium, pRootSnapshot, pCurrentSnapshot, uLevel, 0); + + // recurse into children + SafeIfaceArray<IMedium> aChildren; + CHECK_ERROR_BREAK(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(aChildren))); + for (uint32_t i = 0; + i < aChildren.size(); + ++i) + { + ComPtr<IMedium> pChild(aChildren[i]); + DumpMediumWithChildren(pCurrentStateMedium, pChild, pRootSnapshot, pCurrentSnapshot, uLevel + 1); + } + } while (0); +} + + +/** + * Handles the 'snapshot myvm list' sub-command. + * @returns Exit code. + * @param pArgs The handler argument package. + * @param pMachine Reference to the VM (locked) we're operating on. + */ +static RTEXITCODE handleSnapshotList(HandlerArg *pArgs, ComPtr<IMachine> &pMachine) +{ + static const RTGETOPTDEF g_aOptions[] = + { + { "--details", 'D', RTGETOPT_REQ_NOTHING }, + { "--machinereadable", 'M', RTGETOPT_REQ_NOTHING }, + }; + + VMINFO_DETAILS enmDetails = VMINFO_STANDARD; + + int c; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, pArgs->argc, pArgs->argv, g_aOptions, RT_ELEMENTS(g_aOptions), 2 /*iArg*/, 0 /*fFlags*/); + while ((c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 'D': enmDetails = VMINFO_FULL; break; + case 'M': enmDetails = VMINFO_MACHINEREADABLE; break; + default: return errorGetOpt(USAGE_SNAPSHOT, c, &ValueUnion); + } + } + + ComPtr<ISnapshot> pSnapshot; + HRESULT hrc = pMachine->FindSnapshot(Bstr().raw(), pSnapshot.asOutParam()); + if (FAILED(hrc)) + { + RTPrintf("This machine does not have any snapshots\n"); + return RTEXITCODE_FAILURE; + } + if (pSnapshot) + { + ComPtr<ISnapshot> pCurrentSnapshot; + CHECK_ERROR2I_RET(pMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam()), RTEXITCODE_FAILURE); + hrc = showSnapshots(pSnapshot, pCurrentSnapshot, enmDetails); + if (FAILED(hrc)) + return RTEXITCODE_FAILURE; + } + return RTEXITCODE_SUCCESS; +} + +/** + * Implementation for "VBoxManage snapshot ... dump". This goes thru the machine's + * medium attachments and calls DumpMediumWithChildren() for each hard disk medium found, + * which then dumps the parent/child tree of that medium together with the corresponding + * snapshots. + * @param pMachine Machine to dump snapshots for. + */ +void DumpSnapshot(ComPtr<IMachine> &pMachine) +{ + HRESULT rc; + + do + { + // get root snapshot + ComPtr<ISnapshot> pSnapshot; + CHECK_ERROR_BREAK(pMachine, FindSnapshot(Bstr("").raw(), pSnapshot.asOutParam())); + + // get current snapshot + ComPtr<ISnapshot> pCurrentSnapshot; + CHECK_ERROR_BREAK(pMachine, COMGETTER(CurrentSnapshot)(pCurrentSnapshot.asOutParam())); + + // get media attachments + SafeIfaceArray<IMediumAttachment> aAttachments; + CHECK_ERROR_BREAK(pMachine, COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(aAttachments))); + for (uint32_t i = 0; + i < aAttachments.size(); + ++i) + { + ComPtr<IMediumAttachment> pAttach(aAttachments[i]); + DeviceType_T type; + CHECK_ERROR_BREAK(pAttach, COMGETTER(Type)(&type)); + if (type == DeviceType_HardDisk) + { + ComPtr<IMedium> pCurrentStateMedium; + CHECK_ERROR_BREAK(pAttach, COMGETTER(Medium)(pCurrentStateMedium.asOutParam())); + + ComPtr<IMedium> pBaseMedium; + CHECK_ERROR_BREAK(pCurrentStateMedium, COMGETTER(Base)(pBaseMedium.asOutParam())); + + Bstr bstrBaseMediumName; + CHECK_ERROR_BREAK(pBaseMedium, COMGETTER(Name)(bstrBaseMediumName.asOutParam())); + + RTPrintf("[%RI32] Images and snapshots for medium \"%ls\"\n", i, bstrBaseMediumName.raw()); + + DumpMediumWithChildren(pCurrentStateMedium, + pBaseMedium, + pSnapshot, + pCurrentSnapshot, + 0); + } + } + } while (0); +} + +typedef enum SnapshotUniqueFlags +{ + SnapshotUniqueFlags_Null = 0, + SnapshotUniqueFlags_Number = RT_BIT(1), + SnapshotUniqueFlags_Timestamp = RT_BIT(2), + SnapshotUniqueFlags_Space = RT_BIT(16), + SnapshotUniqueFlags_Force = RT_BIT(30) +} SnapshotUniqueFlags; + +static int parseSnapshotUniqueFlags(const char *psz, SnapshotUniqueFlags *pUnique) +{ + int rc = VINF_SUCCESS; + unsigned uUnique = 0; + while (psz && *psz && RT_SUCCESS(rc)) + { + size_t len; + const char *pszComma = strchr(psz, ','); + if (pszComma) + len = pszComma - psz; + else + len = strlen(psz); + if (len > 0) + { + if (!RTStrNICmp(psz, "number", len)) + uUnique |= SnapshotUniqueFlags_Number; + else if (!RTStrNICmp(psz, "timestamp", len)) + uUnique |= SnapshotUniqueFlags_Timestamp; + else if (!RTStrNICmp(psz, "space", len)) + uUnique |= SnapshotUniqueFlags_Space; + else if (!RTStrNICmp(psz, "force", len)) + uUnique |= SnapshotUniqueFlags_Force; + else + rc = VERR_PARSE_ERROR; + } + if (pszComma) + psz += len + 1; + else + psz += len; + } + + if (RT_SUCCESS(rc)) + *pUnique = (SnapshotUniqueFlags)uUnique; + return rc; +} + +/** + * Implementation for all VBoxManage snapshot ... subcommands. + * @param a + * @return + */ +RTEXITCODE handleSnapshot(HandlerArg *a) +{ + HRESULT rc; + + /* we need at least a VM and a command */ + if (a->argc < 2) + return errorSyntax(USAGE_SNAPSHOT, "Not enough parameters"); + + /* the first argument must be the VM */ + Bstr bstrMachine(a->argv[0]); + ComPtr<IMachine> pMachine; + CHECK_ERROR(a->virtualBox, FindMachine(bstrMachine.raw(), + pMachine.asOutParam())); + if (!pMachine) + return RTEXITCODE_FAILURE; + + /* we have to open a session for this task (new or shared) */ + CHECK_ERROR_RET(pMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + do + { + /* replace the (read-only) IMachine object by a writable one */ + ComPtr<IMachine> sessionMachine; + CHECK_ERROR_BREAK(a->session, COMGETTER(Machine)(sessionMachine.asOutParam())); + + /* switch based on the command */ + bool fDelete = false, + fRestore = false, + fRestoreCurrent = false; + + if (!strcmp(a->argv[1], "take")) + { + /* there must be a name */ + if (a->argc < 3) + { + errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name"); + rc = E_FAIL; + break; + } + Bstr name(a->argv[2]); + + /* parse the optional arguments */ + Bstr desc; + bool fPause = true; /* default is NO live snapshot */ + SnapshotUniqueFlags enmUnique = SnapshotUniqueFlags_Null; + static const RTGETOPTDEF s_aTakeOptions[] = + { + { "--description", 'd', RTGETOPT_REQ_STRING }, + { "-description", 'd', RTGETOPT_REQ_STRING }, + { "-desc", 'd', RTGETOPT_REQ_STRING }, + { "--pause", 'p', RTGETOPT_REQ_NOTHING }, + { "--live", 'l', RTGETOPT_REQ_NOTHING }, + { "--uniquename", 'u', RTGETOPT_REQ_STRING } + }; + RTGETOPTSTATE GetOptState; + RTGetOptInit(&GetOptState, a->argc, a->argv, s_aTakeOptions, RT_ELEMENTS(s_aTakeOptions), + 3, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + int ch; + RTGETOPTUNION Value; + int vrc; + while ( SUCCEEDED(rc) + && (ch = RTGetOpt(&GetOptState, &Value))) + { + switch (ch) + { + case 'p': + fPause = true; + break; + + case 'l': + fPause = false; + break; + + case 'd': + desc = Value.psz; + break; + + case 'u': + vrc = parseSnapshotUniqueFlags(Value.psz, &enmUnique); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid unique name description '%s'", Value.psz); + break; + + default: + errorGetOpt(USAGE_SNAPSHOT, ch, &Value); + rc = E_FAIL; + break; + } + } + if (FAILED(rc)) + break; + + if (enmUnique & (SnapshotUniqueFlags_Number | SnapshotUniqueFlags_Timestamp)) + { + ComPtr<ISnapshot> pSnapshot; + rc = sessionMachine->FindSnapshot(name.raw(), + pSnapshot.asOutParam()); + if (SUCCEEDED(rc) || (enmUnique & SnapshotUniqueFlags_Force)) + { + /* there is a duplicate, need to create a unique name */ + uint32_t count = 0; + RTTIMESPEC now; + + if (enmUnique & SnapshotUniqueFlags_Number) + { + if (enmUnique & SnapshotUniqueFlags_Force) + count = 1; + else + count = 2; + RTTimeSpecSetNano(&now, 0); /* Shut up MSC */ + } + else + RTTimeNow(&now); + + while (count < 500) + { + Utf8Str suffix; + if (enmUnique & SnapshotUniqueFlags_Number) + suffix = Utf8StrFmt("%u", count); + else + { + RTTIMESPEC nowplus = now; + RTTimeSpecAddSeconds(&nowplus, count); + RTTIME stamp; + RTTimeExplode(&stamp, &nowplus); + suffix = Utf8StrFmt("%04u-%02u-%02uT%02u:%02u:%02uZ", stamp.i32Year, stamp.u8Month, stamp.u8MonthDay, stamp.u8Hour, stamp.u8Minute, stamp.u8Second); + } + Bstr tryName = name; + if (enmUnique & SnapshotUniqueFlags_Space) + tryName = BstrFmt("%ls %s", name.raw(), suffix.c_str()); + else + tryName = BstrFmt("%ls%s", name.raw(), suffix.c_str()); + count++; + rc = sessionMachine->FindSnapshot(tryName.raw(), + pSnapshot.asOutParam()); + if (FAILED(rc)) + { + name = tryName; + break; + } + } + if (SUCCEEDED(rc)) + { + errorArgument("Failed to generate a unique snapshot name"); + rc = E_FAIL; + break; + } + } + rc = S_OK; + } + + ComPtr<IProgress> progress; + Bstr snapId; + CHECK_ERROR_BREAK(sessionMachine, TakeSnapshot(name.raw(), desc.raw(), + fPause, snapId.asOutParam(), + progress.asOutParam())); + + rc = showProgress(progress); + if (SUCCEEDED(rc)) + RTPrintf("Snapshot taken. UUID: %ls\n", snapId.raw()); + else + CHECK_PROGRESS_ERROR(progress, ("Failed to take snapshot")); + } + else if ( (fDelete = !strcmp(a->argv[1], "delete")) + || (fRestore = !strcmp(a->argv[1], "restore")) + || (fRestoreCurrent = !strcmp(a->argv[1], "restorecurrent")) + ) + { + if (fRestoreCurrent) + { + if (a->argc > 2) + { + errorSyntax(USAGE_SNAPSHOT, "Too many arguments"); + rc = E_FAIL; + break; + } + } + /* exactly one parameter: snapshot name */ + else if (a->argc != 3) + { + errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only"); + rc = E_FAIL; + break; + } + + ComPtr<ISnapshot> pSnapshot; + + if (fRestoreCurrent) + { + CHECK_ERROR_BREAK(sessionMachine, COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam())); + if (pSnapshot.isNull()) + { + RTPrintf("This machine does not have any snapshots\n"); + return RTEXITCODE_FAILURE; + } + } + else + { + // restore or delete snapshot: then resolve cmd line argument to snapshot instance + CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(a->argv[2]).raw(), + pSnapshot.asOutParam())); + } + + Bstr bstrSnapGuid; + CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Id)(bstrSnapGuid.asOutParam())); + + Bstr bstrSnapName; + CHECK_ERROR_BREAK(pSnapshot, COMGETTER(Name)(bstrSnapName.asOutParam())); + + ComPtr<IProgress> pProgress; + + RTPrintf("%s snapshot '%ls' (%ls)\n", + fDelete ? "Deleting" : "Restoring", bstrSnapName.raw(), bstrSnapGuid.raw()); + + if (fDelete) + { + CHECK_ERROR_BREAK(sessionMachine, DeleteSnapshot(bstrSnapGuid.raw(), + pProgress.asOutParam())); + } + else + { + // restore or restore current + CHECK_ERROR_BREAK(sessionMachine, RestoreSnapshot(pSnapshot, pProgress.asOutParam())); + } + + rc = showProgress(pProgress); + CHECK_PROGRESS_ERROR(pProgress, ("Snapshot operation failed")); + } + else if (!strcmp(a->argv[1], "edit")) + { + if (a->argc < 3) + { + errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name"); + rc = E_FAIL; + break; + } + + ComPtr<ISnapshot> pSnapshot; + + if ( !strcmp(a->argv[2], "--current") + || !strcmp(a->argv[2], "-current")) + { + CHECK_ERROR_BREAK(sessionMachine, COMGETTER(CurrentSnapshot)(pSnapshot.asOutParam())); + if (pSnapshot.isNull()) + { + RTPrintf("This machine does not have any snapshots\n"); + return RTEXITCODE_FAILURE; + } + } + else + { + CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(a->argv[2]).raw(), + pSnapshot.asOutParam())); + } + + /* parse options */ + for (int i = 3; i < a->argc; i++) + { + if ( !strcmp(a->argv[i], "--name") + || !strcmp(a->argv[i], "-name") + || !strcmp(a->argv[i], "-newname")) + { + if (a->argc <= i + 1) + { + errorArgument("Missing argument to '%s'", a->argv[i]); + rc = E_FAIL; + break; + } + i++; + pSnapshot->COMSETTER(Name)(Bstr(a->argv[i]).raw()); + } + else if ( !strcmp(a->argv[i], "--description") + || !strcmp(a->argv[i], "-description") + || !strcmp(a->argv[i], "-newdesc")) + { + if (a->argc <= i + 1) + { + errorArgument("Missing argument to '%s'", a->argv[i]); + rc = E_FAIL; + break; + } + i++; + pSnapshot->COMSETTER(Description)(Bstr(a->argv[i]).raw()); + } + else + { + errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(a->argv[i]).c_str()); + rc = E_FAIL; + break; + } + } + + } + else if (!strcmp(a->argv[1], "showvminfo")) + { + /* exactly one parameter: snapshot name */ + if (a->argc != 3) + { + errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only"); + rc = E_FAIL; + break; + } + + ComPtr<ISnapshot> pSnapshot; + + CHECK_ERROR_BREAK(sessionMachine, FindSnapshot(Bstr(a->argv[2]).raw(), + pSnapshot.asOutParam())); + + /* get the machine of the given snapshot */ + ComPtr<IMachine> pMachine2; + pSnapshot->COMGETTER(Machine)(pMachine2.asOutParam()); + showVMInfo(a->virtualBox, pMachine2, NULL, VMINFO_NONE); + } + else if (!strcmp(a->argv[1], "list")) + rc = handleSnapshotList(a, sessionMachine) == RTEXITCODE_SUCCESS ? S_OK : E_FAIL; + else if (!strcmp(a->argv[1], "dump")) // undocumented parameter to debug snapshot info + DumpSnapshot(sessionMachine); + else + { + errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(a->argv[1]).c_str()); + rc = E_FAIL; + } + } while (0); + + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp new file mode 100644 index 00000000..0e1b7a28 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageStorageController.cpp @@ -0,0 +1,1290 @@ +/* $Id: VBoxManageStorageController.cpp $ */ +/** @file + * VBoxManage - The storage controller related commands. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef VBOX_ONLY_DOCS + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/com/com.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include <iprt/path.h> +#include <iprt/param.h> +#include <iprt/string.h> +#include <iprt/ctype.h> +#include <iprt/stream.h> +#include <iprt/getopt.h> +#include <VBox/log.h> + +#include "VBoxManage.h" +using namespace com; + + +// funcs +/////////////////////////////////////////////////////////////////////////////// + + +static const RTGETOPTDEF g_aStorageAttachOptions[] = +{ + { "--storagectl", 's', RTGETOPT_REQ_STRING }, + { "--port", 'p', RTGETOPT_REQ_UINT32 }, + { "--device", 'd', RTGETOPT_REQ_UINT32 }, + { "--type", 't', RTGETOPT_REQ_STRING }, + { "--medium", 'm', RTGETOPT_REQ_STRING }, + { "--mtype", 'M', RTGETOPT_REQ_STRING }, + { "--passthrough", 'h', RTGETOPT_REQ_STRING }, + { "--tempeject", 'e', RTGETOPT_REQ_STRING }, + { "--nonrotational", 'n', RTGETOPT_REQ_STRING }, + { "--discard", 'u', RTGETOPT_REQ_STRING }, + { "--hotpluggable", 'o', RTGETOPT_REQ_STRING }, + { "--bandwidthgroup", 'b', RTGETOPT_REQ_STRING }, + { "--forceunmount", 'f', RTGETOPT_REQ_NOTHING }, + { "--comment", 'C', RTGETOPT_REQ_STRING }, + { "--setuuid", 'q', RTGETOPT_REQ_STRING }, + { "--setparentuuid", 'Q', RTGETOPT_REQ_STRING }, + // iSCSI options + { "--server", 'S', RTGETOPT_REQ_STRING }, + { "--target", 'T', RTGETOPT_REQ_STRING }, + { "--tport", 'P', RTGETOPT_REQ_STRING }, + { "--lun", 'L', RTGETOPT_REQ_STRING }, + { "--encodedlun", 'E', RTGETOPT_REQ_STRING }, + { "--username", 'U', RTGETOPT_REQ_STRING }, + { "--password", 'W', RTGETOPT_REQ_STRING }, + { "--passwordfile", 'w', RTGETOPT_REQ_STRING }, + { "--initiator", 'N', RTGETOPT_REQ_STRING }, + { "--intnet", 'I', RTGETOPT_REQ_NOTHING }, +}; + +RTEXITCODE handleStorageAttach(HandlerArg *a) +{ + int c = VERR_INTERNAL_ERROR; /* initialized to shut up gcc */ + HRESULT rc = S_OK; + ULONG port = ~0U; + ULONG device = ~0U; + bool fForceUnmount = false; + bool fSetMediumType = false; + bool fSetNewUuid = false; + bool fSetNewParentUuid = false; + MediumType_T enmMediumType = MediumType_Normal; + Bstr bstrComment; + const char *pszCtl = NULL; + DeviceType_T devTypeRequested = DeviceType_Null; + const char *pszMedium = NULL; + const char *pszPassThrough = NULL; + const char *pszTempEject = NULL; + const char *pszNonRotational = NULL; + const char *pszDiscard = NULL; + const char *pszHotPluggable = NULL; + const char *pszBandwidthGroup = NULL; + Bstr bstrNewUuid; + Bstr bstrNewParentUuid; + // iSCSI options + Bstr bstrServer; + Bstr bstrTarget; + Bstr bstrPort; + Bstr bstrLun; + Bstr bstrUsername; + Bstr bstrPassword; + Bstr bstrInitiator; + Bstr bstrIso; + Utf8Str strIso; + bool fIntNet = false; + + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + ComPtr<IMachine> machine; + ComPtr<IStorageController> storageCtl; + ComPtr<ISystemProperties> systemProperties; + + RTGetOptInit(&GetState, a->argc, a->argv, g_aStorageAttachOptions, + RT_ELEMENTS(g_aStorageAttachOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + while ( SUCCEEDED(rc) + && (c = RTGetOpt(&GetState, &ValueUnion))) + { + switch (c) + { + case 's': // storage controller name + { + if (ValueUnion.psz) + pszCtl = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'p': // port + { + port = ValueUnion.u32; + break; + } + + case 'd': // device + { + device = ValueUnion.u32; + break; + } + + case 'm': // medium <none|emptydrive|additions|uuid|filename|host:<drive>|iSCSI> + { + if (ValueUnion.psz) + pszMedium = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 't': // type <dvddrive|hdd|fdd> + { + if (ValueUnion.psz) + { + if (!RTStrICmp(ValueUnion.psz, "hdd")) + devTypeRequested = DeviceType_HardDisk; + else if (!RTStrICmp(ValueUnion.psz, "fdd")) + devTypeRequested = DeviceType_Floppy; + else if (!RTStrICmp(ValueUnion.psz, "dvddrive")) + devTypeRequested = DeviceType_DVD; + else + return errorArgument("Invalid --type argument '%s'", ValueUnion.psz); + } + else + rc = E_FAIL; + break; + } + + case 'h': // passthrough <on|off> + { + if (ValueUnion.psz) + pszPassThrough = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'e': // tempeject <on|off> + { + if (ValueUnion.psz) + pszTempEject = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'n': // nonrotational <on|off> + { + if (ValueUnion.psz) + pszNonRotational = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'u': // discard <on|off> + { + if (ValueUnion.psz) + pszDiscard = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'o': // hotpluggable <on|off> + { + if (ValueUnion.psz) + pszHotPluggable = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'b': // bandwidthgroup <name> + { + if (ValueUnion.psz) + pszBandwidthGroup = ValueUnion.psz; + else + rc = E_FAIL; + break; + } + + case 'f': // force unmount medium during runtime + { + fForceUnmount = true; + break; + } + + case 'C': + if (ValueUnion.psz) + bstrComment = ValueUnion.psz; + else + rc = E_FAIL; + break; + + case 'q': + if (ValueUnion.psz) + { + bstrNewUuid = ValueUnion.psz; + fSetNewUuid = true; + } + else + rc = E_FAIL; + break; + + case 'Q': + if (ValueUnion.psz) + { + bstrNewParentUuid = ValueUnion.psz; + fSetNewParentUuid = true; + } + else + rc = E_FAIL; + break; + + case 'S': // --server + bstrServer = ValueUnion.psz; + break; + + case 'T': // --target + bstrTarget = ValueUnion.psz; + break; + + case 'P': // --tport + bstrPort = ValueUnion.psz; + break; + + case 'L': // --lun + bstrLun = ValueUnion.psz; + break; + + case 'E': // --encodedlun + bstrLun = BstrFmt("enc%s", ValueUnion.psz); + break; + + case 'U': // --username + bstrUsername = ValueUnion.psz; + break; + + case 'W': // --password + bstrPassword = ValueUnion.psz; + break; + + case 'w': // --passwordFile + { + Utf8Str utf8Password; + RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &utf8Password); + if (rcExit != RTEXITCODE_SUCCESS) + rc = E_FAIL; + bstrPassword = utf8Password; + break; + } + case 'N': // --initiator + bstrInitiator = ValueUnion.psz; + break; + + case 'M': // --type + { + int vrc = parseMediumType(ValueUnion.psz, &enmMediumType); + if (RT_FAILURE(vrc)) + return errorArgument("Invalid medium type '%s'", ValueUnion.psz); + fSetMediumType = true; + break; + } + + case 'I': // --intnet + fIntNet = true; + break; + + default: + { + errorGetOpt(USAGE_STORAGEATTACH, c, &ValueUnion); + rc = E_FAIL; + break; + } + } + } + + if (FAILED(rc)) + return RTEXITCODE_FAILURE; + + if (!pszCtl) + return errorSyntax(USAGE_STORAGEATTACH, "Storage controller name not specified"); + + /* get the virtualbox system properties */ + CHECK_ERROR_RET(a->virtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), RTEXITCODE_FAILURE); + + // find the machine, lock it, get the mutable session machine + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + SessionType_T st; + CHECK_ERROR_RET(a->session, COMGETTER(Type)(&st), RTEXITCODE_FAILURE); + a->session->COMGETTER(Machine)(machine.asOutParam()); + + try + { + bool fRunTime = (st == SessionType_Shared); + + if (fRunTime) + { + if (pszPassThrough) + throw Utf8Str("Drive passthrough state cannot be changed while the VM is running\n"); + else if (pszBandwidthGroup) + throw Utf8Str("Bandwidth group cannot be changed while the VM is running\n"); + } + + /* check if the storage controller is present */ + rc = machine->GetStorageControllerByName(Bstr(pszCtl).raw(), + storageCtl.asOutParam()); + if (FAILED(rc)) + throw Utf8StrFmt("Could not find a controller named '%s'\n", pszCtl); + + StorageBus_T storageBus = StorageBus_Null; + CHECK_ERROR_RET(storageCtl, COMGETTER(Bus)(&storageBus), RTEXITCODE_FAILURE); + ULONG maxPorts = 0; + CHECK_ERROR_RET(systemProperties, GetMaxPortCountForStorageBus(storageBus, &maxPorts), RTEXITCODE_FAILURE); + ULONG maxDevices = 0; + CHECK_ERROR_RET(systemProperties, GetMaxDevicesPerPortForStorageBus(storageBus, &maxDevices), RTEXITCODE_FAILURE); + + if (port == ~0U) + { + if (maxPorts == 1) + port = 0; + else + return errorSyntax(USAGE_STORAGEATTACH, "Port not specified"); + } + if (device == ~0U) + { + if (maxDevices == 1) + device = 0; + else + return errorSyntax(USAGE_STORAGEATTACH, "Device not specified"); + } + + /* for sata controller check if the port count is big enough + * to accommodate the current port which is being assigned + * else just increase the port count + */ + { + ULONG ulPortCount = 0; + ULONG ulMaxPortCount = 0; + + CHECK_ERROR(storageCtl, COMGETTER(MaxPortCount)(&ulMaxPortCount)); + CHECK_ERROR(storageCtl, COMGETTER(PortCount)(&ulPortCount)); + + if ( (ulPortCount != ulMaxPortCount) + && (port >= ulPortCount) + && (port < ulMaxPortCount)) + CHECK_ERROR(storageCtl, COMSETTER(PortCount)(port + 1)); + } + + StorageControllerType_T ctlType = StorageControllerType_Null; + CHECK_ERROR(storageCtl, COMGETTER(ControllerType)(&ctlType)); + + if (!RTStrICmp(pszMedium, "none")) + { + CHECK_ERROR(machine, DetachDevice(Bstr(pszCtl).raw(), port, device)); + } + else if (!RTStrICmp(pszMedium, "emptydrive")) + { + if (fRunTime) + { + ComPtr<IMediumAttachment> mediumAttachment; + DeviceType_T deviceType = DeviceType_Null; + rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, device, + mediumAttachment.asOutParam()); + if (SUCCEEDED(rc)) + { + mediumAttachment->COMGETTER(Type)(&deviceType); + + if ( (deviceType == DeviceType_DVD) + || (deviceType == DeviceType_Floppy)) + { + /* just unmount the floppy/dvd */ + CHECK_ERROR(machine, UnmountMedium(Bstr(pszCtl).raw(), + port, + device, + fForceUnmount)); + } + } + else if (devTypeRequested == DeviceType_DVD) + { + /* + * Try to attach an empty DVD drive as a hotplug operation. + * Main will complain if the controller doesn't support hotplugging. + */ + CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), port, device, + devTypeRequested)); + deviceType = DeviceType_DVD; /* To avoid the error message below. */ + } + + if ( FAILED(rc) + || !( deviceType == DeviceType_DVD + || deviceType == DeviceType_Floppy) + ) + throw Utf8StrFmt("No DVD/Floppy Drive attached to the controller '%s'" + "at the port: %u, device: %u", pszCtl, port, device); + + } + else + { + DeviceType_T deviceType = DeviceType_Null; + com::SafeArray <DeviceType_T> saDeviceTypes; + ULONG driveCheck = 0; + + /* check if the device type is supported by the controller */ + CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes))); + for (size_t i = 0; i < saDeviceTypes.size(); ++ i) + { + if ( (saDeviceTypes[i] == DeviceType_DVD) + || (saDeviceTypes[i] == DeviceType_Floppy)) + driveCheck++; + } + + if (!driveCheck) + throw Utf8StrFmt("The attachment is not supported by the storage controller '%s'", pszCtl); + + if (storageBus == StorageBus_Floppy) + deviceType = DeviceType_Floppy; + else + deviceType = DeviceType_DVD; + + /* attach a empty floppy/dvd drive after removing previous attachment */ + machine->DetachDevice(Bstr(pszCtl).raw(), port, device); + CHECK_ERROR(machine, AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), port, device, + deviceType)); + } + } // end if (!RTStrICmp(pszMedium, "emptydrive")) + else + { + ComPtr<IMedium> pMedium2Mount; + + // not "none", not "emptydrive": then it must be a UUID or filename or hostdrive or iSCSI; + // for all these we first need to know the type of drive we're attaching to + { + /* + * try to determine the type of the drive from the + * storage controller chipset, the attachment and + * the medium being attached + */ + if (ctlType == StorageControllerType_I82078) // floppy controller + devTypeRequested = DeviceType_Floppy; + else + { + /* + * for SATA/SCSI/IDE it is hard to tell if it is a harddisk or + * a dvd being attached so lets check if the medium attachment + * and the medium, both are of same type. if yes then we are + * sure of its type and don't need the user to enter it manually + * else ask the user for the type. + */ + ComPtr<IMediumAttachment> mediumAttachment; + rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, + mediumAttachment.asOutParam()); + if (SUCCEEDED(rc)) + { + DeviceType_T deviceType; + mediumAttachment->COMGETTER(Type)(&deviceType); + + if (pszMedium) + { + if (!RTStrICmp(pszMedium, "additions")) + { + ComPtr<ISystemProperties> pProperties; + CHECK_ERROR(a->virtualBox, + COMGETTER(SystemProperties)(pProperties.asOutParam())); + CHECK_ERROR(pProperties, COMGETTER(DefaultAdditionsISO)(bstrIso.asOutParam())); + strIso = Utf8Str(bstrIso); + if (strIso.isEmpty()) + throw Utf8Str("Cannot find the Guest Additions ISO image\n"); + pszMedium = strIso.c_str(); + if (devTypeRequested == DeviceType_Null) + devTypeRequested = DeviceType_DVD; + } + ComPtr<IMedium> pExistingMedium; + rc = openMedium(a, pszMedium, deviceType, + AccessMode_ReadWrite, + pExistingMedium, + false /* fForceNewUuidOnOpen */, + true /* fSilent */); + if (SUCCEEDED(rc) && pExistingMedium) + { + if ( (deviceType == DeviceType_DVD) + || (deviceType == DeviceType_HardDisk) + ) + devTypeRequested = deviceType; + } + } + else + devTypeRequested = deviceType; + } + } + } + + if (devTypeRequested == DeviceType_Null) // still the initializer value? + throw Utf8Str("Argument --type must be specified\n"); + + /* check if the device type is supported by the controller */ + { + com::SafeArray <DeviceType_T> saDeviceTypes; + + CHECK_ERROR(systemProperties, GetDeviceTypesForStorageBus(storageBus, ComSafeArrayAsOutParam(saDeviceTypes))); + if (SUCCEEDED(rc)) + { + ULONG driveCheck = 0; + for (size_t i = 0; i < saDeviceTypes.size(); ++ i) + if (saDeviceTypes[i] == devTypeRequested) + driveCheck++; + if (!driveCheck) + throw Utf8StrFmt("The given attachment is not supported by the storage controller '%s'", pszCtl); + } + else + goto leave; + } + + // find the medium given + /* host drive? */ + if (!RTStrNICmp(pszMedium, RT_STR_TUPLE("host:"))) + { + ComPtr<IHost> host; + CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam())); + + if (devTypeRequested == DeviceType_DVD) + { + rc = host->FindHostDVDDrive(Bstr(pszMedium + 5).raw(), + pMedium2Mount.asOutParam()); + if (!pMedium2Mount) + { + /* 2nd try: try with the real name, important on Linux+libhal */ + char szPathReal[RTPATH_MAX]; + if (RT_FAILURE(RTPathReal(pszMedium + 5, szPathReal, sizeof(szPathReal)))) + throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5); + rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(), + pMedium2Mount.asOutParam()); + if (!pMedium2Mount) + throw Utf8StrFmt("Invalid host DVD drive name \"%s\"", pszMedium + 5); + } + } + else + { + // floppy + rc = host->FindHostFloppyDrive(Bstr(pszMedium + 5).raw(), + pMedium2Mount.asOutParam()); + if (!pMedium2Mount) + throw Utf8StrFmt("Invalid host floppy drive name \"%s\"", pszMedium + 5); + } + } + else if (!RTStrICmp(pszMedium, "iSCSI")) + { + /* check for required options */ + if (bstrServer.isEmpty() || bstrTarget.isEmpty()) + throw Utf8StrFmt("Parameters --server and --target are required for iSCSI media"); + + /** @todo move the location stuff to Main, which can use pfnComposeName + * from the disk backends to construct the location properly. Also do + * not use slashes to separate the parts, as otherwise only the last + * element containing information will be shown. */ + Bstr bstrISCSIMedium; + if ( bstrLun.isEmpty() + || (bstrLun == "0") + || (bstrLun == "enc0") + ) + bstrISCSIMedium = BstrFmt("%ls|%ls", bstrServer.raw(), bstrTarget.raw()); + else + bstrISCSIMedium = BstrFmt("%ls|%ls|%ls", bstrServer.raw(), bstrTarget.raw(), bstrLun.raw()); + + CHECK_ERROR(a->virtualBox, CreateMedium(Bstr("iSCSI").raw(), + bstrISCSIMedium.raw(), + AccessMode_ReadWrite, + DeviceType_HardDisk, + pMedium2Mount.asOutParam())); + if (FAILED(rc)) goto leave; + if (!bstrPort.isEmpty()) + bstrServer = BstrFmt("%ls:%ls", bstrServer.raw(), bstrPort.raw()); + + // set the other iSCSI parameters as properties + com::SafeArray <BSTR> names; + com::SafeArray <BSTR> values; + Bstr("TargetAddress").detachTo(names.appendedRaw()); + bstrServer.detachTo(values.appendedRaw()); + Bstr("TargetName").detachTo(names.appendedRaw()); + bstrTarget.detachTo(values.appendedRaw()); + + if (!bstrLun.isEmpty()) + { + Bstr("LUN").detachTo(names.appendedRaw()); + bstrLun.detachTo(values.appendedRaw()); + } + if (!bstrUsername.isEmpty()) + { + Bstr("InitiatorUsername").detachTo(names.appendedRaw()); + bstrUsername.detachTo(values.appendedRaw()); + } + if (!bstrPassword.isEmpty()) + { + Bstr("InitiatorSecret").detachTo(names.appendedRaw()); + bstrPassword.detachTo(values.appendedRaw()); + } + if (!bstrInitiator.isEmpty()) + { + Bstr("InitiatorName").detachTo(names.appendedRaw()); + bstrInitiator.detachTo(values.appendedRaw()); + } + + /// @todo add --targetName and --targetPassword options + + if (fIntNet) + { + Bstr("HostIPStack").detachTo(names.appendedRaw()); + Bstr("0").detachTo(values.appendedRaw()); + } + + CHECK_ERROR(pMedium2Mount, SetProperties(ComSafeArrayAsInParam(names), + ComSafeArrayAsInParam(values))); + if (FAILED(rc)) goto leave; + Bstr guid; + CHECK_ERROR(pMedium2Mount, COMGETTER(Id)(guid.asOutParam())); + if (FAILED(rc)) goto leave; + RTPrintf("iSCSI disk created. UUID: %s\n", Utf8Str(guid).c_str()); + } + else + { + if (!pszMedium) + { + ComPtr<IMediumAttachment> mediumAttachment; + rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, + mediumAttachment.asOutParam()); + if (FAILED(rc)) + throw Utf8Str("Missing --medium argument"); + } + else + { + Bstr bstrMedium(pszMedium); + rc = openMedium(a, pszMedium, devTypeRequested, + AccessMode_ReadWrite, pMedium2Mount, + fSetNewUuid, false /* fSilent */); + if (FAILED(rc) || !pMedium2Mount) + throw Utf8StrFmt("Invalid UUID or filename \"%s\"", pszMedium); + } + } + + // set medium/parent medium UUID, if so desired + if (pMedium2Mount && (fSetNewUuid || fSetNewParentUuid)) + { + CHECK_ERROR(pMedium2Mount, SetIds(fSetNewUuid, bstrNewUuid.raw(), + fSetNewParentUuid, bstrNewParentUuid.raw())); + if (FAILED(rc)) + throw Utf8Str("Failed to set the medium/parent medium UUID"); + } + + // set medium type, if so desired + if (pMedium2Mount && fSetMediumType) + { + MediumType_T enmMediumTypeOld; + CHECK_ERROR(pMedium2Mount, COMGETTER(Type)(&enmMediumTypeOld)); + if (SUCCEEDED(rc)) + { + if (enmMediumTypeOld != enmMediumType) + { + CHECK_ERROR(pMedium2Mount, COMSETTER(Type)(enmMediumType)); + if (FAILED(rc)) + throw Utf8Str("Failed to set the medium type"); + } + } + } + + if (pMedium2Mount && !bstrComment.isEmpty()) + { + CHECK_ERROR(pMedium2Mount, COMSETTER(Description)(bstrComment.raw())); + } + + if (pszMedium) + { + switch (devTypeRequested) + { + case DeviceType_DVD: + case DeviceType_Floppy: + { + if (!fRunTime) + { + ComPtr<IMediumAttachment> mediumAttachment; + // check if there is a dvd/floppy drive at the given location, if not attach one first + rc = machine->GetMediumAttachment(Bstr(pszCtl).raw(), + port, + device, + mediumAttachment.asOutParam()); + if (SUCCEEDED(rc)) + { + DeviceType_T deviceType; + mediumAttachment->COMGETTER(Type)(&deviceType); + if (deviceType != devTypeRequested) + { + machine->DetachDevice(Bstr(pszCtl).raw(), port, device); + rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), + port, + device, + devTypeRequested); // DeviceType_DVD or DeviceType_Floppy + } + } + else + { + rc = machine->AttachDeviceWithoutMedium(Bstr(pszCtl).raw(), + port, + device, + devTypeRequested); // DeviceType_DVD or DeviceType_Floppy + } + } + + if (pMedium2Mount) + { + CHECK_ERROR(machine, MountMedium(Bstr(pszCtl).raw(), + port, + device, + pMedium2Mount, + fForceUnmount)); + } + break; + } // end DeviceType_DVD or DeviceType_Floppy: + + case DeviceType_HardDisk: + { + // if there is anything attached at the given location, remove it + machine->DetachDevice(Bstr(pszCtl).raw(), port, device); + CHECK_ERROR(machine, AttachDevice(Bstr(pszCtl).raw(), + port, + device, + DeviceType_HardDisk, + pMedium2Mount)); + break; + } + + default: break; /* Shut up MSC */ + } + } + } + + if ( pszPassThrough + && (SUCCEEDED(rc))) + { + ComPtr<IMediumAttachment> mattach; + CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, mattach.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszPassThrough, "on")) + { + CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(), + port, device, TRUE)); + } + else if (!RTStrICmp(pszPassThrough, "off")) + { + CHECK_ERROR(machine, PassthroughDevice(Bstr(pszCtl).raw(), + port, device, FALSE)); + } + else + throw Utf8StrFmt("Invalid --passthrough argument '%s'", pszPassThrough); + } + else + throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl); + } + + if ( pszTempEject + && (SUCCEEDED(rc))) + { + ComPtr<IMediumAttachment> mattach; + CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, mattach.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszTempEject, "on")) + { + CHECK_ERROR(machine, TemporaryEjectDevice(Bstr(pszCtl).raw(), + port, device, TRUE)); + } + else if (!RTStrICmp(pszTempEject, "off")) + { + CHECK_ERROR(machine, TemporaryEjectDevice(Bstr(pszCtl).raw(), + port, device, FALSE)); + } + else + throw Utf8StrFmt("Invalid --tempeject argument '%s'", pszTempEject); + } + else + throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl); + } + + if ( pszNonRotational + && (SUCCEEDED(rc))) + { + ComPtr<IMediumAttachment> mattach; + CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, mattach.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszNonRotational, "on")) + { + CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(), + port, device, TRUE)); + } + else if (!RTStrICmp(pszNonRotational, "off")) + { + CHECK_ERROR(machine, NonRotationalDevice(Bstr(pszCtl).raw(), + port, device, FALSE)); + } + else + throw Utf8StrFmt("Invalid --nonrotational argument '%s'", pszNonRotational); + } + else + throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl); + } + + if ( pszDiscard + && (SUCCEEDED(rc))) + { + ComPtr<IMediumAttachment> mattach; + CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, mattach.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszDiscard, "on")) + { + CHECK_ERROR(machine, SetAutoDiscardForDevice(Bstr(pszCtl).raw(), + port, device, TRUE)); + } + else if (!RTStrICmp(pszDiscard, "off")) + { + CHECK_ERROR(machine, SetAutoDiscardForDevice(Bstr(pszCtl).raw(), + port, device, FALSE)); + } + else + throw Utf8StrFmt("Invalid --discard argument '%s'", pszDiscard); + } + else + throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl); + } + + if ( pszHotPluggable + && (SUCCEEDED(rc))) + { + ComPtr<IMediumAttachment> mattach; + CHECK_ERROR(machine, GetMediumAttachment(Bstr(pszCtl).raw(), port, + device, mattach.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszHotPluggable, "on")) + { + CHECK_ERROR(machine, SetHotPluggableForDevice(Bstr(pszCtl).raw(), + port, device, TRUE)); + } + else if (!RTStrICmp(pszHotPluggable, "off")) + { + CHECK_ERROR(machine, SetHotPluggableForDevice(Bstr(pszCtl).raw(), + port, device, FALSE)); + } + else + throw Utf8StrFmt("Invalid --hotpluggable argument '%s'", pszHotPluggable); + } + else + throw Utf8StrFmt("Couldn't find the controller attachment for the controller '%s'\n", pszCtl); + } + + if ( pszBandwidthGroup + && !fRunTime + && SUCCEEDED(rc)) + { + + if (!RTStrICmp(pszBandwidthGroup, "none")) + { + /* Just remove the bandwidth gorup. */ + CHECK_ERROR(machine, SetNoBandwidthGroupForDevice(Bstr(pszCtl).raw(), + port, device)); + } + else + { + ComPtr<IBandwidthControl> bwCtrl; + ComPtr<IBandwidthGroup> bwGroup; + + CHECK_ERROR(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam())); + + if (SUCCEEDED(rc)) + { + CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(pszBandwidthGroup).raw(), bwGroup.asOutParam())); + if (SUCCEEDED(rc)) + { + CHECK_ERROR(machine, SetBandwidthGroupForDevice(Bstr(pszCtl).raw(), + port, device, bwGroup)); + } + } + } + } + + /* commit changes */ + if (SUCCEEDED(rc)) + CHECK_ERROR(machine, SaveSettings()); + } + catch (const Utf8Str &strError) + { + errorArgument("%s", strError.c_str()); + rc = E_FAIL; + } + + // machine must always be unlocked, even on errors +leave: + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + + +static const RTGETOPTDEF g_aStorageControllerOptions[] = +{ + { "--name", 'n', RTGETOPT_REQ_STRING }, + { "--add", 'a', RTGETOPT_REQ_STRING }, + { "--controller", 'c', RTGETOPT_REQ_STRING }, + { "--portcount", 'p', RTGETOPT_REQ_UINT32 }, + { "--remove", 'r', RTGETOPT_REQ_NOTHING }, + { "--rename", 'R', RTGETOPT_REQ_STRING }, + { "--hostiocache", 'i', RTGETOPT_REQ_STRING }, + { "--bootable", 'b', RTGETOPT_REQ_STRING }, +}; + +RTEXITCODE handleStorageController(HandlerArg *a) +{ + int c; + const char *pszCtl = NULL; + const char *pszBusType = NULL; + const char *pszCtlType = NULL; + const char *pszHostIOCache = NULL; + const char *pszBootable = NULL; + const char *pszCtlNewName = NULL; + ULONG portcount = ~0U; + bool fRemoveCtl = false; + ComPtr<IMachine> machine; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + + if (a->argc < 4) + return errorSyntax(USAGE_STORAGECONTROLLER, "Too few parameters"); + + RTGetOptInit (&GetState, a->argc, a->argv, g_aStorageControllerOptions, + RT_ELEMENTS(g_aStorageControllerOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS); + + while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (c) + { + case 'n': // controller name + Assert(ValueUnion.psz); + pszCtl = ValueUnion.psz; + break; + + case 'a': // controller bus type <ide/sata/scsi/floppy> + Assert(ValueUnion.psz); + pszBusType = ValueUnion.psz; + break; + + case 'c': // controller <lsilogic/buslogic/intelahci/piix3/piix4/ich6/i82078> + Assert(ValueUnion.psz); + pszCtlType = ValueUnion.psz; + break; + + case 'p': // portcount + portcount = ValueUnion.u32; + break; + + case 'r': // remove controller + fRemoveCtl = true; + break; + + case 'R': // rename controller + Assert(ValueUnion.psz); + pszCtlNewName = ValueUnion.psz; + break; + + case 'i': + pszHostIOCache = ValueUnion.psz; + break; + + case 'b': + pszBootable = ValueUnion.psz; + break; + + default: + return errorGetOpt(USAGE_STORAGECONTROLLER, c, &ValueUnion); + } + } + + HRESULT rc; + + /* try to find the given machine */ + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(), + machine.asOutParam()), RTEXITCODE_FAILURE); + + /* open a session for the VM */ + CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE); + + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(machine.asOutParam()); + + if (!pszCtl) + { + /* it's important to always close sessions */ + a->session->UnlockMachine(); + return errorSyntax(USAGE_STORAGECONTROLLER, "Storage controller name not specified\n"); + } + + if (fRemoveCtl) + { + CHECK_ERROR(machine, RemoveStorageController(Bstr(pszCtl).raw())); + } + else + { + if (pszBusType) + { + ComPtr<IStorageController> ctl; + + if (!RTStrICmp(pszBusType, "ide")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_IDE, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "sata")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_SATA, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "scsi")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_SCSI, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "floppy")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_Floppy, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "sas")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_SAS, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "usb")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_USB, + ctl.asOutParam())); + } + else if (!RTStrICmp(pszBusType, "pcie")) + { + CHECK_ERROR(machine, AddStorageController(Bstr(pszCtl).raw(), + StorageBus_PCIe, + ctl.asOutParam())); + } + else + { + errorArgument("Invalid --add argument '%s'", pszBusType); + rc = E_FAIL; + } + } + + if ( pszCtlType + && SUCCEEDED(rc)) + { + ComPtr<IStorageController> ctl; + + CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(), + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszCtlType, "lsilogic")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic)); + } + else if (!RTStrICmp(pszCtlType, "buslogic")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic)); + } + else if (!RTStrICmp(pszCtlType, "intelahci")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci)); + } + else if (!RTStrICmp(pszCtlType, "piix3")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_PIIX3)); + } + else if (!RTStrICmp(pszCtlType, "piix4")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_PIIX4)); + } + else if (!RTStrICmp(pszCtlType, "ich6")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_ICH6)); + } + else if (!RTStrICmp(pszCtlType, "i82078")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_I82078)); + } + else if (!RTStrICmp(pszCtlType, "lsilogicsas")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogicSas)); + } + else if (!RTStrICmp(pszCtlType, "usb")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_USB)); + } + else if (!RTStrICmp(pszCtlType, "nvme")) + { + CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_NVMe)); + } + else + { + errorArgument("Invalid --type argument '%s'", pszCtlType); + rc = E_FAIL; + } + } + else + { + errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl); + rc = E_FAIL; + } + } + + if ( (portcount != ~0U) + && SUCCEEDED(rc)) + { + ComPtr<IStorageController> ctl; + + CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(), + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + { + CHECK_ERROR(ctl, COMSETTER(PortCount)(portcount)); + } + else + { + errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl); + rc = E_FAIL; + } + } + + if ( pszHostIOCache + && SUCCEEDED(rc)) + { + ComPtr<IStorageController> ctl; + + CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(), + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszHostIOCache, "on")) + { + CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(TRUE)); + } + else if (!RTStrICmp(pszHostIOCache, "off")) + { + CHECK_ERROR(ctl, COMSETTER(UseHostIOCache)(FALSE)); + } + else + { + errorArgument("Invalid --hostiocache argument '%s'", pszHostIOCache); + rc = E_FAIL; + } + } + else + { + errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl); + rc = E_FAIL; + } + } + + if ( pszBootable + && SUCCEEDED(rc)) + { + if (SUCCEEDED(rc)) + { + if (!RTStrICmp(pszBootable, "on")) + { + CHECK_ERROR(machine, SetStorageControllerBootable(Bstr(pszCtl).raw(), TRUE)); + } + else if (!RTStrICmp(pszBootable, "off")) + { + CHECK_ERROR(machine, SetStorageControllerBootable(Bstr(pszCtl).raw(), FALSE)); + } + else + { + errorArgument("Invalid --bootable argument '%s'", pszBootable); + rc = E_FAIL; + } + } + else + { + errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl); + rc = E_FAIL; + } + } + + if ( pszCtlNewName + && SUCCEEDED(rc)) + { + ComPtr<IStorageController> ctl; + + CHECK_ERROR(machine, GetStorageControllerByName(Bstr(pszCtl).raw(), + ctl.asOutParam())); + + if (SUCCEEDED(rc)) + { + CHECK_ERROR(ctl, COMSETTER(Name)(Bstr(pszCtlNewName).raw())); + } + else + { + errorArgument("Couldn't find the controller with the name: '%s'\n", pszCtl); + rc = E_FAIL; + } + } + + } + + /* commit changes */ + if (SUCCEEDED(rc)) + CHECK_ERROR(machine, SaveSettings()); + + /* it's important to always close sessions */ + a->session->UnlockMachine(); + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +#endif /* !VBOX_ONLY_DOCS */ + diff --git a/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp b/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp new file mode 100644 index 00000000..237c85d0 --- /dev/null +++ b/src/VBox/Frontends/VBoxManage/VBoxManageUSB.cpp @@ -0,0 +1,600 @@ +/* $Id: VBoxManageUSB.cpp $ */ +/** @file + * VBoxManage - VirtualBox's command-line interface. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include <VBox/com/com.h> +#include <VBox/com/string.h> +#include <VBox/com/Guid.h> +#include <VBox/com/array.h> +#include <VBox/com/ErrorInfo.h> +#include <VBox/com/errorprint.h> +#include <VBox/com/VirtualBox.h> + +#include "VBoxManage.h" + +#include <iprt/asm.h> + +using namespace com; + +/** + * Quick IUSBDevice implementation for detaching / attaching + * devices to the USB Controller. + */ +class MyUSBDevice : public IUSBDevice +{ +public: + // public initializer/uninitializer for internal purposes only + MyUSBDevice(uint16_t a_u16VendorId, uint16_t a_u16ProductId, uint16_t a_bcdRevision, uint64_t a_u64SerialHash, const char *a_pszComment) + : m_usVendorId(a_u16VendorId), m_usProductId(a_u16ProductId), + m_bcdRevision(a_bcdRevision), m_u64SerialHash(a_u64SerialHash), + m_bstrComment(a_pszComment), + m_cRefs(0) + { + } + virtual ~MyUSBDevice() {} + + STDMETHOD_(ULONG, AddRef)(void) + { + return ASMAtomicIncU32(&m_cRefs); + } + STDMETHOD_(ULONG, Release)(void) + { + ULONG cRefs = ASMAtomicDecU32(&m_cRefs); + if (!cRefs) + delete this; + return cRefs; + } + STDMETHOD(QueryInterface)(const IID &iid, void **ppvObject) + { + Guid guid(iid); + if (guid == Guid(COM_IIDOF(IUnknown))) + *ppvObject = (IUnknown *)this; +#ifdef RT_OS_WINDOWS + else if (guid == Guid(COM_IIDOF(IDispatch))) + *ppvObject = (IDispatch *)this; +#endif + else if (guid == Guid(COM_IIDOF(IUSBDevice))) + *ppvObject = (IUSBDevice *)this; + else + return E_NOINTERFACE; + AddRef(); + return S_OK; + } + + STDMETHOD(COMGETTER(Id))(OUT_GUID a_pId) { NOREF(a_pId); return E_NOTIMPL; } + STDMETHOD(COMGETTER(VendorId))(USHORT *a_pusVendorId) { *a_pusVendorId = m_usVendorId; return S_OK; } + STDMETHOD(COMGETTER(ProductId))(USHORT *a_pusProductId) { *a_pusProductId = m_usProductId; return S_OK; } + STDMETHOD(COMGETTER(Revision))(USHORT *a_pusRevision) { *a_pusRevision = m_bcdRevision; return S_OK; } + STDMETHOD(COMGETTER(SerialHash))(ULONG64 *a_pullSerialHash) { *a_pullSerialHash = m_u64SerialHash; return S_OK; } + STDMETHOD(COMGETTER(Manufacturer))(BSTR *a_pManufacturer) { NOREF(a_pManufacturer); return E_NOTIMPL; } + STDMETHOD(COMGETTER(Product))(BSTR *a_pProduct) { NOREF(a_pProduct); return E_NOTIMPL; } + STDMETHOD(COMGETTER(SerialNumber))(BSTR *a_pSerialNumber) { NOREF(a_pSerialNumber); return E_NOTIMPL; } + STDMETHOD(COMGETTER(Address))(BSTR *a_pAddress) { NOREF(a_pAddress); return E_NOTIMPL; } + +private: + /** The vendor id of this USB device. */ + USHORT m_usVendorId; + /** The product id of this USB device. */ + USHORT m_usProductId; + /** The product revision number of this USB device. + * (high byte = integer; low byte = decimal) */ + USHORT m_bcdRevision; + /** The USB serial hash of the device. */ + uint64_t m_u64SerialHash; + /** The user comment string. */ + Bstr m_bstrComment; + /** Reference counter. */ + uint32_t volatile m_cRefs; +}; + + +// types +/////////////////////////////////////////////////////////////////////////////// + +template <typename T> +class Nullable +{ +public: + + Nullable() : mIsNull(true) {} + Nullable(const T &aValue, bool aIsNull = false) + : mIsNull(aIsNull), mValue(aValue) {} + + bool isNull() const { return mIsNull; }; + void setNull(bool aIsNull = true) { mIsNull = aIsNull; } + + operator const T&() const { return mValue; } + + Nullable &operator= (const T &aValue) + { + mValue = aValue; + mIsNull = false; + return *this; + } + +private: + + bool mIsNull; + T mValue; +}; + +/** helper structure to encapsulate USB filter manipulation commands */ +struct USBFilterCmd +{ + struct USBFilter + { + USBFilter() + : mAction(USBDeviceFilterAction_Null) + {} + + Bstr mName; + Nullable <bool> mActive; + Bstr mVendorId; + Bstr mProductId; + Bstr mRevision; + Bstr mManufacturer; + Bstr mProduct; + Bstr mRemote; + Bstr mSerialNumber; + Nullable <ULONG> mMaskedInterfaces; + USBDeviceFilterAction_T mAction; + }; + + enum Action { Invalid, Add, Modify, Remove }; + + USBFilterCmd() : mAction(Invalid), mIndex(0), mGlobal(false) {} + + Action mAction; + uint32_t mIndex; + /** flag whether the command target is a global filter */ + bool mGlobal; + /** machine this command is targeted at (null for global filters) */ + ComPtr<IMachine> mMachine; + USBFilter mFilter; +}; + +RTEXITCODE handleUSBFilter(HandlerArg *a) +{ + HRESULT rc = S_OK; + USBFilterCmd cmd; + + /* at least: 0: command, 1: index, 2: --target, 3: <target value> */ + if (a->argc < 4) + return errorSyntax(USAGE_USBFILTER, "Not enough parameters"); + + /* which command? */ + cmd.mAction = USBFilterCmd::Invalid; + if (!strcmp(a->argv[0], "add")) cmd.mAction = USBFilterCmd::Add; + else if (!strcmp(a->argv[0], "modify")) cmd.mAction = USBFilterCmd::Modify; + else if (!strcmp(a->argv[0], "remove")) cmd.mAction = USBFilterCmd::Remove; + + if (cmd.mAction == USBFilterCmd::Invalid) + return errorSyntax(USAGE_USBFILTER, "Invalid parameter '%s'", a->argv[0]); + + /* which index? */ + if (VINF_SUCCESS != RTStrToUInt32Full(a->argv[1], 10, &cmd.mIndex)) + return errorSyntax(USAGE_USBFILTER, "Invalid index '%s'", a->argv[1]); + + switch (cmd.mAction) + { + case USBFilterCmd::Add: + case USBFilterCmd::Modify: + { + /* at least: 0: command, 1: index, 2: --target, 3: <target value>, 4: --name, 5: <name value> */ + if (a->argc < 6) + { + if (cmd.mAction == USBFilterCmd::Add) + return errorSyntax(USAGE_USBFILTER_ADD, "Not enough parameters"); + + return errorSyntax(USAGE_USBFILTER_MODIFY, "Not enough parameters"); + } + + // set Active to true by default + // (assuming that the user sets up all necessary attributes + // at once and wants the filter to be active immediately) + if (cmd.mAction == USBFilterCmd::Add) + cmd.mFilter.mActive = true; + + for (int i = 2; i < a->argc; i++) + { + if ( !strcmp(a->argv[i], "--target") + || !strcmp(a->argv[i], "-target")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + if (!strcmp(a->argv[i], "global")) + cmd.mGlobal = true; + else + { + /* assume it's a UUID of a machine */ + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(), + cmd.mMachine.asOutParam()), RTEXITCODE_FAILURE); + } + } + else if ( !strcmp(a->argv[i], "--name") + || !strcmp(a->argv[i], "-name")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mName = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--active") + || !strcmp(a->argv[i], "-active")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + if (!strcmp(a->argv[i], "yes")) + cmd.mFilter.mActive = true; + else if (!strcmp(a->argv[i], "no")) + cmd.mFilter.mActive = false; + else + return errorArgument("Invalid --active argument '%s'", a->argv[i]); + } + else if ( !strcmp(a->argv[i], "--vendorid") + || !strcmp(a->argv[i], "-vendorid")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mVendorId = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--productid") + || !strcmp(a->argv[i], "-productid")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mProductId = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--revision") + || !strcmp(a->argv[i], "-revision")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mRevision = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--manufacturer") + || !strcmp(a->argv[i], "-manufacturer")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mManufacturer = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--product") + || !strcmp(a->argv[i], "-product")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mProduct = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--remote") + || !strcmp(a->argv[i], "-remote")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mRemote = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--serialnumber") + || !strcmp(a->argv[i], "-serialnumber")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + cmd.mFilter.mSerialNumber = a->argv[i]; + } + else if ( !strcmp(a->argv[i], "--maskedinterfaces") + || !strcmp(a->argv[i], "-maskedinterfaces")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + uint32_t u32; + int vrc = RTStrToUInt32Full(a->argv[i], 0, &u32); + if (RT_FAILURE(vrc)) + return errorArgument("Failed to convert the --maskedinterfaces value '%s' to a number, vrc=%Rrc", a->argv[i], vrc); + cmd.mFilter.mMaskedInterfaces = u32; + } + else if ( !strcmp(a->argv[i], "--action") + || !strcmp(a->argv[i], "-action")) + { + if (a->argc <= i + 1) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + if (!strcmp(a->argv[i], "ignore")) + cmd.mFilter.mAction = USBDeviceFilterAction_Ignore; + else if (!strcmp(a->argv[i], "hold")) + cmd.mFilter.mAction = USBDeviceFilterAction_Hold; + else + return errorArgument("Invalid USB filter action '%s'", a->argv[i]); + } + else + return errorSyntax(cmd.mAction == USBFilterCmd::Add ? USAGE_USBFILTER_ADD : USAGE_USBFILTER_MODIFY, + "Unknown option '%s'", a->argv[i]); + } + + if (cmd.mAction == USBFilterCmd::Add) + { + // mandatory/forbidden options + if ( cmd.mFilter.mName.isEmpty() + || + ( cmd.mGlobal + && cmd.mFilter.mAction == USBDeviceFilterAction_Null + ) + || ( !cmd.mGlobal + && !cmd.mMachine) + || ( cmd.mGlobal + && !cmd.mFilter.mRemote.isEmpty()) + ) + { + return errorSyntax(USAGE_USBFILTER_ADD, "Mandatory options not supplied"); + } + } + break; + } + + case USBFilterCmd::Remove: + { + /* at least: 0: command, 1: index, 2: --target, 3: <target value> */ + if (a->argc < 4) + return errorSyntax(USAGE_USBFILTER_REMOVE, "Not enough parameters"); + + for (int i = 2; i < a->argc; i++) + { + if ( !strcmp(a->argv[i], "--target") + || !strcmp(a->argv[i], "-target")) + { + if (a->argc <= i + 1 || !*a->argv[i+1]) + return errorArgument("Missing argument to '%s'", a->argv[i]); + i++; + if (!strcmp(a->argv[i], "global")) + cmd.mGlobal = true; + else + { + CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[i]).raw(), + cmd.mMachine.asOutParam()), RTEXITCODE_FAILURE); + } + } + } + + // mandatory options + if (!cmd.mGlobal && !cmd.mMachine) + return errorSyntax(USAGE_USBFILTER_REMOVE, "Mandatory options not supplied"); + + break; + } + + default: break; + } + + USBFilterCmd::USBFilter &f = cmd.mFilter; + + ComPtr<IHost> host; + ComPtr<IUSBDeviceFilters> flts; + if (cmd.mGlobal) + CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + else + { + /* open a session for the VM */ + CHECK_ERROR_RET(cmd.mMachine, LockMachine(a->session, LockType_Shared), RTEXITCODE_FAILURE); + /* get the mutable session machine */ + a->session->COMGETTER(Machine)(cmd.mMachine.asOutParam()); + /* and get the USB device filters */ + CHECK_ERROR_RET(cmd.mMachine, COMGETTER(USBDeviceFilters)(flts.asOutParam()), RTEXITCODE_FAILURE); + } + + switch (cmd.mAction) + { + case USBFilterCmd::Add: + { + if (cmd.mGlobal) + { + ComPtr<IHostUSBDeviceFilter> flt; + CHECK_ERROR_BREAK(host, CreateUSBDeviceFilter(f.mName.raw(), + flt.asOutParam())); + + if (!f.mActive.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive)); + if (!f.mVendorId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw())); + if (!f.mProductId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw())); + if (!f.mRevision.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw())); + if (!f.mManufacturer.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw())); + if (!f.mSerialNumber.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw())); + if (!f.mMaskedInterfaces.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces)); + + if (f.mAction != USBDeviceFilterAction_Null) + CHECK_ERROR_BREAK(flt, COMSETTER(Action)(f.mAction)); + + CHECK_ERROR_BREAK(host, InsertUSBDeviceFilter(cmd.mIndex, flt)); + } + else + { + ComPtr<IUSBDeviceFilter> flt; + CHECK_ERROR_BREAK(flts, CreateDeviceFilter(f.mName.raw(), + flt.asOutParam())); + + if (!f.mActive.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive)); + if (!f.mVendorId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw())); + if (!f.mProductId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw())); + if (!f.mRevision.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw())); + if (!f.mManufacturer.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw())); + if (!f.mRemote.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Remote)(f.mRemote.raw())); + if (!f.mSerialNumber.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw())); + if (!f.mMaskedInterfaces.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces)); + + CHECK_ERROR_BREAK(flts, InsertDeviceFilter(cmd.mIndex, flt)); + } + break; + } + case USBFilterCmd::Modify: + { + if (cmd.mGlobal) + { + SafeIfaceArray <IHostUSBDeviceFilter> coll; + CHECK_ERROR_BREAK(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll))); + + ComPtr<IHostUSBDeviceFilter> flt = coll[cmd.mIndex]; + + if (!f.mName.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Name)(f.mName.raw())); + if (!f.mActive.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive)); + if (!f.mVendorId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw())); + if (!f.mProductId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw())); + if (!f.mRevision.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw())); + if (!f.mManufacturer.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw())); + if (!f.mSerialNumber.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw())); + if (!f.mMaskedInterfaces.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces)); + + if (f.mAction != USBDeviceFilterAction_Null) + CHECK_ERROR_BREAK(flt, COMSETTER(Action)(f.mAction)); + } + else + { + SafeIfaceArray <IUSBDeviceFilter> coll; + CHECK_ERROR_BREAK(flts, COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(coll))); + + ComPtr<IUSBDeviceFilter> flt = coll[cmd.mIndex]; + + if (!f.mName.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Name)(f.mName.raw())); + if (!f.mActive.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(Active)(f.mActive)); + if (!f.mVendorId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(VendorId)(f.mVendorId.raw())); + if (!f.mProductId.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(ProductId)(f.mProductId.raw())); + if (!f.mRevision.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Revision)(f.mRevision.raw())); + if (!f.mManufacturer.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Manufacturer)(f.mManufacturer.raw())); + if (!f.mRemote.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(Remote)(f.mRemote.raw())); + if (!f.mSerialNumber.isEmpty()) + CHECK_ERROR_BREAK(flt, COMSETTER(SerialNumber)(f.mSerialNumber.raw())); + if (!f.mMaskedInterfaces.isNull()) + CHECK_ERROR_BREAK(flt, COMSETTER(MaskedInterfaces)(f.mMaskedInterfaces)); + } + break; + } + case USBFilterCmd::Remove: + { + if (cmd.mGlobal) + { + ComPtr<IHostUSBDeviceFilter> flt; + CHECK_ERROR_BREAK(host, RemoveUSBDeviceFilter(cmd.mIndex)); + } + else + { + ComPtr<IUSBDeviceFilter> flt; + CHECK_ERROR_BREAK(flts, RemoveDeviceFilter(cmd.mIndex, flt.asOutParam())); + } + break; + } + default: + break; + } + + if (cmd.mMachine) + { + if (SUCCEEDED(rc)) + { + /* commit the session */ + CHECK_ERROR(cmd.mMachine, SaveSettings()); + } + /* close the session */ + a->session->UnlockMachine(); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +RTEXITCODE handleUSBDevSource(HandlerArg *a) +{ + HRESULT rc = S_OK; + + /* at least: 0: command, 1: source id */ + if (a->argc < 2) + return errorSyntax(USAGE_USBDEVSOURCE, "Not enough parameters"); + + ComPtr<IHost> host; + if (!strcmp(a->argv[0], "add")) + { + Bstr strBackend; + Bstr strAddress; + if (a->argc != 6) + return errorSyntax(USAGE_USBDEVSOURCE, "Invalid number of parameters"); + + for (int i = 2; i < a->argc; i++) + { + if (!strcmp(a->argv[i], "--backend")) + { + i++; + strBackend = a->argv[i]; + } + else if (!strcmp(a->argv[i], "--address")) + { + i++; + strAddress = a->argv[i]; + } + else + return errorSyntax(USAGE_USBDEVSOURCE, "Parameter \"%s\" is invalid", a->argv[i]); + } + + SafeArray<BSTR> usbSourcePropNames; + SafeArray<BSTR> usbSourcePropValues; + + CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(host, AddUSBDeviceSource(strBackend.raw(), Bstr(a->argv[1]).raw(), strAddress.raw(), + ComSafeArrayAsInParam(usbSourcePropNames), ComSafeArrayAsInParam(usbSourcePropValues)), + RTEXITCODE_FAILURE); + } + else if (!strcmp(a->argv[0], "remove")) + { + CHECK_ERROR_RET(a->virtualBox, COMGETTER(Host)(host.asOutParam()), RTEXITCODE_FAILURE); + CHECK_ERROR_RET(host, RemoveUSBDeviceSource(Bstr(a->argv[1]).raw()), RTEXITCODE_FAILURE); + } + + return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + +/* vi: set tabstop=4 shiftwidth=4 expandtab: */ |