#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/EventQueue.h>

#include <VBox/com/VirtualBox.h>

#include <stdlib.h>

#include <stdarg.h>

#include <vector>

#include <list>

#include <iprt/runtime.h>

#include <iprt/stream.h>

#include <iprt/string.h>

#include <iprt/asm.h>

#include <iprt/uuid.h>

#include <iprt/thread.h>

#include <iprt/path.h>

#include <iprt/param.h>

#include <iprt/dir.h>

#include <iprt/file.h>

#include <iprt/env.h>

#include <iprt/cidr.h>

#include <VBox/err.h>

#include <VBox/version.h>

#include <VBox/VBoxHDD.h>

#include "VBoxManage.h"

using namespace com;

#ifndef STDMETHOD_

# define STDMETHOD_(ret, meth) NS_IMETHOD_(ret) meth

#endif

#ifndef NS_GET_IID

# define NS_GET_IID(I) IID_##I

#endif

#ifndef RT_OS_WINDOWS

#define IUnknown nsISupports

#endif

typedef DECLCALLBACK(int) FNHANDLER(int argc, char *argv[], ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession);

typedef FNHANDLER *PFNHANDLER;

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)

{

}

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(NS_GET_IID(IUnknown)))

*ppvObject = (IUnknown *)this;

else if (guid == Guid(NS_GET_IID(IUSBDevice)))

*ppvObject = (IUSBDevice *)this;

else

return E_NOINTERFACE;

AddRef();

return S_OK;

}

STDMETHOD(COMGETTER(Id))(GUIDPARAMOUT 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) { return E_NOTIMPL; }

STDMETHOD(COMGETTER(Product))(BSTR *a_pProduct) { return E_NOTIMPL; }

STDMETHOD(COMGETTER(SerialNumber))(BSTR *a_pSerialNumber) { return E_NOTIMPL; }

STDMETHOD(COMGETTER(Address))(BSTR *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.

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;

};

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;

};

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;

ULONG 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;

};

static void showLogo(void)

{

static bool fShown; /* show only once */

if (!fShown)

{

RTPrintf("VirtualBox Command Line Management Interface Version "

VBOX_VERSION_STRING "\n"

"(C) 2005-2008 Sun Microsystems, Inc.\n"

"All rights reserved.\n"

"\n");

fShown = true;

}

}

static void printUsage(USAGECATEGORY u64Cmd)

{

#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_DARWIN

bool fDarwin = true;

#else

bool fDarwin = false;

#endif

#ifdef VBOX_VRDP

bool fVRDP = true;

#else

bool fVRDP = false;

#endif

if (u64Cmd == USAGE_DUMPOPTS)

{

fLinux = true;

fWin = true;

fSolaris = true;

fDarwin = true;

fVRDP = true;

u64Cmd = USAGE_ALL;

}

RTPrintf("Usage:\n"

"\n");

if (u64Cmd == USAGE_ALL)

{

RTPrintf("VBoxManage [-v|-version] print version number and exit\n"

"VBoxManage -nologo ... suppress the logo\n"

"\n"

"VBoxManage -convertSettings ... allow to auto-convert settings files\n"

"VBoxManage -convertSettingsBackup ... allow to auto-convert settings files\n"

" but create backup copies before\n"

"VBoxManage -convertSettingsIgnore ... allow to auto-convert settings files\n"

" but don't explicitly save the results\n"

"\n");

}

if (u64Cmd & USAGE_LIST)

{

RTPrintf("VBoxManage list vms|runningvms|ostypes|hostdvds|hostfloppies|\n"

" hostifs|hostinfo|hdds|dvds|floppies|\n"

" usbhost|usbfilters|systemproperties\n"

"\n");

}

if (u64Cmd & USAGE_SHOWVMINFO)

{

RTPrintf("VBoxManage showvminfo <uuid>|<name>\n"

" [-details]\n"

" [-statistics]\n"

" [-machinereadable]\n"

"\n");

}

if (u64Cmd & USAGE_REGISTERVM)

{

RTPrintf("VBoxManage registervm <filename>\n"

"\n");

}

if (u64Cmd & USAGE_UNREGISTERVM)

{

RTPrintf("VBoxManage unregistervm <uuid>|<name>\n"

" [-delete]\n"

"\n");

}

if (u64Cmd & USAGE_CREATEVM)

{

RTPrintf("VBoxManage createvm -name <name>\n"

" [-register]\n"

" [-basefolder <path> | -settingsfile <path>]\n"

" [-uuid <uuid>]\n"

" \n"

"\n");

}

if (u64Cmd & USAGE_MODIFYVM)

{

RTPrintf("VBoxManage modifyvm <uuid|name>\n"

" [-name <name>]\n"

" [-ostype <ostype>]\n"

" [-memory <memorysize>]\n"

" [-vram <vramsize>]\n"

" [-acpi on|off]\n"

" [-ioapic on|off]\n"

" [-pae on|off]\n"

" [-hwvirtex on|off|default]\n"

" [-nestedpaging on|off]\n"

" [-monitorcount <number>]\n"

" [-bioslogofadein on|off]\n"

" [-bioslogofadeout on|off]\n"

" [-bioslogodisplaytime <msec>]\n"

" [-bioslogoimagepath <imagepath>]\n"

" [-biosbootmenu disabled|menuonly|messageandmenu]\n"

" [-biossystemtimeoffset <msec>]\n"

" [-biospxedebug on|off]\n"

" [-boot<1-4> none|floppy|dvd|disk|net>]\n"

" [-hd<a|b|d> none|<uuid>|<filename>]\n"

" [-idecontroller PIIX3|PIIX4]\n"

#ifdef VBOX_WITH_AHCI

" [-sata on|off]\n"

" [-sataportcount <1-30>]\n"

" [-sataport<1-30> none|<uuid>|<filename>]\n"

" [-sataideemulation<1-4> <1-30>]\n"

#endif

" [-dvd none|<uuid>|<filename>|host:<drive>]\n"

" [-dvdpassthrough on|off]\n"

" [-floppy disabled|empty|<uuid>|\n"

" <filename>|host:<drive>]\n"

" [-nic<1-N> none|null|nat|hostif|intnet]\n"

" [-nictype<1-N> Am79C970A|Am79C973"

#ifdef VBOX_WITH_E1000

"|82540EM|82543GC"

#endif

"]\n"

" [-cableconnected<1-N> on|off]\n"

" [-nictrace<1-N> on|off]\n"

" [-nictracefile<1-N> <filename>]\n"

" [-nicspeed<1-N> <kbps>]\n"

" [-hostifdev<1-N> none|<devicename>]\n"

" [-intnet<1-N> <network name>]\n"

" [-natnet<1-N> <network>|default]\n"

" [-macaddress<1-N> auto|<mac>]\n"

" [-uart<1-N> off|<I/O base> <IRQ>]\n"

" [-uartmode<1-N> disconnected|\n"

" server <pipe>|\n"

" client <pipe>|\n"

" <devicename>]\n"

#ifdef VBOX_WITH_MEM_BALLOONING

" [-guestmemoryballoon <balloonsize>]\n"

#endif

" [-gueststatisticsinterval <seconds>]\n"

);

if (fLinux)

{

RTPrintf(" [-tapsetup<1-N> none|<application>]\n"

" [-tapterminate<1-N> none|<application>]\n");

}

RTPrintf(" [-audio none|null");

if (fWin)

{

#ifdef VBOX_WITH_WINMM

RTPrintf( "|winmm|dsound");

#else

RTPrintf( "|dsound");

#endif

}

if (fSolaris)

{

RTPrintf( "|solaudio");

}

if (fLinux)

{

RTPrintf( "|oss"

#ifdef VBOX_WITH_ALSA

"|alsa"

#endif

#ifdef VBOX_WITH_PULSE

"|pulse"

#endif

);

}

if (fDarwin)

{

RTPrintf( "|coreaudio");

}

RTPrintf( "]\n");

RTPrintf(" [-audiocontroller ac97|sb16]\n"

" [-clipboard disabled|hosttoguest|guesttohost|\n"

" bidirectional]\n");

if (fVRDP)

{

RTPrintf(" [-vrdp on|off]\n"

" [-vrdpport default|<port>]\n"

" [-vrdpaddress <host>]\n"

" [-vrdpauthtype null|external|guest]\n"

" [-vrdpmulticon on|off]\n");

}

RTPrintf(" [-usb on|off]\n"

" [-usbehci on|off]\n"

" [-snapshotfolder default|<path>]\n");

RTPrintf("\n");

}

if (u64Cmd & USAGE_STARTVM)

{

RTPrintf("VBoxManage startvm <uuid>|<name>\n");

if (fVRDP)

RTPrintf(" [-type gui|vrdp]\n");

RTPrintf("\n");

}

if (u64Cmd & USAGE_CONTROLVM)

{

RTPrintf("VBoxManage controlvm <uuid>|<name>\n"

" pause|resume|reset|poweroff|savestate|\n"

" acpipowerbutton|acpisleepbutton|\n"

" keyboardputscancode <hex> [<hex> ...]|\n"

" setlinkstate<1-4> on|off |\n"

" usbattach <uuid>|<address> |\n"

" usbdetach <uuid>|<address> |\n"

" dvdattach none|<uuid>|<filename>|host:<drive> |\n"

" floppyattach none|<uuid>|<filename>|host:<drive> |\n"

" setvideomodehint <xres> <yres> <bpp> [display]|\n"

" setcredentials <username> <password> <domain>\n"

" [-allowlocallogon <yes|no>]\n"

"\n");

}

if (u64Cmd & USAGE_DISCARDSTATE)

{

RTPrintf("VBoxManage discardstate <uuid>|<name>\n"

"\n");

}

if (u64Cmd & USAGE_ADOPTSTATE)

{

RTPrintf("VBoxManage adoptstate <uuid>|<name> <state_file>\n"

"\n");

}

if (u64Cmd & USAGE_SNAPSHOT)

{

RTPrintf("VBoxManage snapshot <uuid>|<name>\n"

" take <name> [-desc <desc>] |\n"

" discard <uuid>|<name> |\n"

" discardcurrent -state|-all |\n"

" edit <uuid>|<name>|-current\n"

" [-newname <name>]\n"

" [-newdesc <desc>] |\n"

" showvminfo <uuid>|<name>\n"

"\n");

}

if (u64Cmd & USAGE_REGISTERIMAGE)

{

RTPrintf("VBoxManage registerimage disk|dvd|floppy <filename>\n"

" [-type normal|immutable|writethrough] (disk only)\n"

"\n");

}

if (u64Cmd & USAGE_UNREGISTERIMAGE)

{

RTPrintf("VBoxManage unregisterimage disk|dvd|floppy <uuid>|<filename>\n"

"\n");

}

if (u64Cmd & USAGE_SHOWVDIINFO)

{

RTPrintf("VBoxManage showvdiinfo <uuid>|<filename>\n"

"\n");

}

if (u64Cmd & USAGE_CREATEVDI)

{

RTPrintf("VBoxManage createvdi -filename <filename>\n"

" -size <megabytes>\n"

" [-static]\n"

" [-comment <comment>]\n"

" [-register]\n"

" [-type normal|writethrough] (default: normal)\n"

"\n");

}

if (u64Cmd & USAGE_MODIFYVDI)

{

RTPrintf("VBoxManage modifyvdi <uuid>|<filename>\n"

#if 0 /* doesn't currently work */

" settype normal|writethrough|immutable |\n"

#endif

" compact\n"

"\n");

}

if (u64Cmd & USAGE_CLONEVDI)

{

RTPrintf("VBoxManage clonevdi <uuid>|<filename> <outputfile>\n"

"\n");

}

if (u64Cmd & USAGE_CONVERTDD)

{

RTPrintf("VBoxManage convertdd [-static] <filename> <outputfile>\n"

"VBoxManage convertdd [-static] stdin <outputfile> <bytes>\n"

"\n");

}

if (u64Cmd & USAGE_ADDISCSIDISK)

{

RTPrintf("VBoxManage addiscsidisk -server <name>|<ip>\n"

" -target <target>\n"

" [-port <port>]\n"

" [-lun <lun>]\n"

" [-encodedlun <lun>]\n"

" [-username <username>]\n"

" [-password <password>]\n"

" [-comment <comment>]\n"

"\n");

}

if (u64Cmd & USAGE_CREATEHOSTIF && fWin)

{

RTPrintf("VBoxManage createhostif <name>\n"

"\n");

}

if (u64Cmd & USAGE_REMOVEHOSTIF && fWin)

{

RTPrintf("VBoxManage removehostif <uuid>|<name>\n"

"\n");

}

if (u64Cmd & USAGE_GETEXTRADATA)

{

RTPrintf("VBoxManage getextradata global|<uuid>|<name>\n"

" <key>|enumerate\n"

"\n");

}

if (u64Cmd & USAGE_SETEXTRADATA)

{

RTPrintf("VBoxManage setextradata global|<uuid>|<name>\n"

" <key>\n"

" [<value>] (no value deletes key)\n"

"\n");

}

if (u64Cmd & USAGE_SETPROPERTY)

{

RTPrintf("VBoxManage setproperty vdifolder default|<folder> |\n"

" machinefolder default|<folder> |\n"

" vrdpauthlibrary default|<library> |\n"

" websrvauthlibrary default|null|<library> |\n"

" hwvirtexenabled yes|no\n"

" loghistorycount <value>\n"

"\n");

}

if (u64Cmd & USAGE_USBFILTER_ADD)

{

RTPrintf("VBoxManage usbfilter add <index,0-N>\n"

" -target <uuid>|<name>|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");

}

if (u64Cmd & USAGE_USBFILTER_MODIFY)

{

RTPrintf("VBoxManage usbfilter modify <index,0-N>\n"

" -target <uuid>|<name>|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");

}

if (u64Cmd & USAGE_USBFILTER_REMOVE)

{

RTPrintf("VBoxManage usbfilter remove <index,0-N>\n"

" -target <uuid>|<name>|global\n"

"\n");

}

if (u64Cmd & USAGE_SHAREDFOLDER_ADD)

{

RTPrintf("VBoxManage sharedfolder add <vmname>|<uuid>\n"

" -name <name> -hostpath <hostpath>\n"

" [-transient] [-readonly]\n"

"\n");

}

if (u64Cmd & USAGE_SHAREDFOLDER_REMOVE)

{

RTPrintf("VBoxManage sharedfolder remove <vmname>|<uuid>\n"

" -name <name> [-transient]\n"

"\n");

}

if (u64Cmd & USAGE_VM_STATISTICS)

{

RTPrintf("VBoxManage vmstatistics <vmname>|<uuid> [-reset]\n"

" [-pattern <pattern>] [-descriptions]\n"

"\n");

}

#ifdef VBOX_WITH_GUEST_PROPS

if (u64Cmd & USAGE_GUESTPROPERTY)

usageGuestProperty();

#endif /* VBOX_WITH_GUEST_PROPS defined */

}

int errorSyntax(USAGECATEGORY u64Cmd, const char *pszFormat, ...)

{

va_list args;

showLogo(); // show logo even if suppressed

if (g_fInternalMode)

printUsageInternal(u64Cmd);

else

printUsage(u64Cmd);

va_start(args, pszFormat);

RTPrintf("\n"

"Syntax error: %N\n", pszFormat, &args);

va_end(args);

return 1;

}

int errorArgument(const char *pszFormat, ...)

{

va_list args;

va_start(args, pszFormat);

RTPrintf("error: %N\n", pszFormat, &args);

va_end(args);

return 1;

}

static void showProgress(ComPtr<IProgress> progress)

{

BOOL fCompleted;

LONG currentPercent;

LONG lastPercent = 0;

RTPrintf("0%%...");

RTStrmFlush(g_pStdOut);

while (SUCCEEDED(progress->COMGETTER(Completed(&fCompleted))))

{

progress->COMGETTER(Percent(&currentPercent));

/* did we cross a 10% mark? */

if (((currentPercent / 10) > (lastPercent / 10)))

{

/* make sure to also print out missed steps */

for (LONG curVal = (lastPercent / 10) * 10 + 10; curVal <= (currentPercent / 10) * 10; curVal += 10)

{

if (curVal < 100)

{

RTPrintf("%ld%%...", curVal);

RTStrmFlush(g_pStdOut);

}

}

lastPercent = (currentPercent / 10) * 10;

}

if (fCompleted)

break;

/* make sure the loop is not too tight */

progress->WaitForCompletion(100);

}

/* complete the line. */

HRESULT rc;

if (SUCCEEDED(progress->COMGETTER(ResultCode)(&rc)))

{

if (SUCCEEDED(rc))

RTPrintf("100%%\n");

else

RTPrintf("FAILED\n");

}

else

RTPrintf("\n");

RTStrmFlush(g_pStdOut);

}

static void showSnapshots(ComPtr<ISnapshot> rootSnapshot, VMINFO_DETAILS details, const Bstr &prefix = "", int level = 0)

{

/* start with the root */

Bstr name;

Guid uuid;

rootSnapshot->COMGETTER(Name)(name.asOutParam());

rootSnapshot->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

/* print with hierarchical numbering */

RTPrintf("SnapshotName%lS=\"%lS\"\n", prefix.raw(), name.raw());

RTPrintf("SnapshotUUID%lS=\"%s\"\n", prefix.raw(), uuid.toString().raw());

}

else

{

/* print with indentation */

RTPrintf(" %lSName: %lS (UUID: %s)\n", prefix.raw(), name.raw(), uuid.toString().raw());

}

/* get the children */

ComPtr<ISnapshotCollection> coll;

rootSnapshot->COMGETTER(Children)(coll.asOutParam());

if (coll)

{

ComPtr<ISnapshotEnumerator> enumerator;

coll->Enumerate(enumerator.asOutParam());

ULONG index = 0;

BOOL hasMore = FALSE;

while (enumerator->HasMore(&hasMore), hasMore)

{

ComPtr<ISnapshot> snapshot;

enumerator->GetNext(snapshot.asOutParam());

if (snapshot)

{

Bstr newPrefix;

if (details == VMINFO_MACHINEREADABLE)

newPrefix = Utf8StrFmt("%lS-%d", prefix.raw(), index + 1);

else

newPrefix = Utf8StrFmt("%lS ", prefix.raw());

/* recursive call */

showSnapshots(snapshot, details, newPrefix, level + 1);

}

index++;

}

}

}

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);

}

static HRESULT showVMInfo (ComPtr <IVirtualBox> virtualBox, ComPtr<IMachine> machine,

ComPtr <IConsole> console = ComPtr <IConsole> (),

VMINFO_DETAILS details = VMINFO_NONE)

{

HRESULT rc;

/*

/** @todo the quoting is not yet implemented! */

BOOL accessible = FALSE;

CHECK_ERROR (machine, COMGETTER(Accessible) (&accessible));

CheckComRCReturnRC (rc);

if (!accessible)

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("name=\"<inaccessible>\"\n");

else

RTPrintf ("Name: <inaccessible!>\n");

Guid uuid;

rc = machine->COMGETTER(Id) (uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf ("UUID=\"%s\"\n", uuid.toString().raw());

else

RTPrintf ("UUID: %s\n", uuid.toString().raw());

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);

PRINT_ERROR_INFO (ei);

RTPrintf ("\n");

}

return S_OK;

}

Bstr machineName;

rc = machine->COMGETTER(Name)(machineName.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("name=\"%lS\"\n", machineName.raw());

else

RTPrintf("Name: %lS\n", machineName.raw());

Bstr osTypeId;

rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());

ComPtr<IGuestOSType> osType;

rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());

Bstr osName;

rc = osType->COMGETTER(Description)(osName.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("ostype=\"%lS\"\n", osTypeId.raw());

else

RTPrintf("Guest OS: %lS\n", osName.raw());

Guid uuid;

rc = machine->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("UUID=\"%s\"\n", uuid.toString().raw());

else

RTPrintf("UUID: %s\n", uuid.toString().raw());

Bstr settingsFilePath;

rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("CfgFile=\"%lS\"\n", settingsFilePath.raw());

else

RTPrintf("Config file: %lS\n", settingsFilePath.raw());

ULONG memorySize;

rc = machine->COMGETTER(MemorySize)(&memorySize);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("memory=%u\n", memorySize);

else

RTPrintf("Memory size: %uMB\n", memorySize);

ULONG vramSize;

rc = machine->COMGETTER(VRAMSize)(&vramSize);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("vram=%u\n", vramSize);

else

RTPrintf("VRAM size: %uMB\n", vramSize);

ComPtr <IBIOSSettings> biosSettings;

machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());

BIOSBootMenuMode_T bootMenuMode;

biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);

const char *pszBootMenu = NULL;

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";

}

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);

else

RTPrintf("Boot menu mode: %s\n", pszBootMenu);

BOOL acpiEnabled;

biosSettings->COMGETTER(ACPIEnabled)(&acpiEnabled);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("acpi=\"%s\"\n", acpiEnabled ? "on" : "off");

else

RTPrintf("ACPI: %s\n", acpiEnabled ? "on" : "off");

BOOL ioapicEnabled;

biosSettings->COMGETTER(IOAPICEnabled)(&ioapicEnabled);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("ioapic=\"%s\"\n", ioapicEnabled ? "on" : "off");

else

RTPrintf("IOAPIC: %s\n", ioapicEnabled ? "on" : "off");

BOOL PAEEnabled;

machine->COMGETTER(PAEEnabled)(&PAEEnabled);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("pae=\"%s\"\n", PAEEnabled ? "on" : "off");

else

RTPrintf("PAE: %s\n", PAEEnabled ? "on" : "off");

LONG64 timeOffset;

biosSettings->COMGETTER(TimeOffset)(&timeOffset);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("biossystemtimeoffset=%lld\n", timeOffset);

else

RTPrintf("Time offset: %lld ms\n", timeOffset);

TSBool_T hwVirtExEnabled;

machine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled);

if (hwVirtExEnabled == TSBool_Default)

{

BOOL fHWVirtExEnabled;

ComPtr<ISystemProperties> systemProperties;

virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());

systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("hwvirtex=\"default\"\n");

else

RTPrintf("Hardw. virt.ext: Default (%s)\n", fHWVirtExEnabled ? "on" : "off");

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("hwvirtex=\"%s\"\n", hwVirtExEnabled == TSBool_True ? "on" : "off");

else

RTPrintf("Hardw. virt.ext: %s\n", hwVirtExEnabled == TSBool_True ? "on" : "off");

}

BOOL HWVirtExNestedPagingEnabled;

machine->COMGETTER(HWVirtExNestedPagingEnabled)(&HWVirtExNestedPagingEnabled);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("nestedpaging=\"%s\"\n", HWVirtExNestedPagingEnabled ? "on" : "off");

else

RTPrintf("Nested Paging: %s\n", HWVirtExNestedPagingEnabled ? "on" : "off");

MachineState_T machineState;

const char *pszState = NULL;

rc = machine->COMGETTER(State)(&machineState);

switch (machineState)

{

case MachineState_PoweredOff:

if (details == VMINFO_MACHINEREADABLE)

pszState = "poweroff";

else

pszState = "powered off";

break;

case MachineState_Saved:

pszState = "saved";

break;

case MachineState_Aborted:

pszState = "aborted";

break;

case MachineState_Running:

pszState = "running";

break;

case MachineState_Paused:

pszState = "paused";

break;

case MachineState_Starting:

pszState = "starting";

break;

case MachineState_Stopping:

pszState = "stopping";

break;

case MachineState_Saving:

pszState = "saving";

break;

case MachineState_Restoring:

pszState = "restoring";

break;

default:

pszState = "unknown";

break;

}

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);

}

else

RTPrintf("State: %s (since %s)\n", pszState, pszTime);

ULONG numMonitors;

machine->COMGETTER(MonitorCount)(&numMonitors);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("monitorcount=%d\n", numMonitors);

else

RTPrintf("Monitor count: %d\n", numMonitors);

ComPtr<IFloppyDrive> floppyDrive;

rc = machine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());

if (SUCCEEDED(rc) && floppyDrive)

{

BOOL fFloppyEnabled;

floppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);

Utf8Str pszFloppy = "invalid";

if (fFloppyEnabled)

{

DriveState_T floppyState;

floppyDrive->COMGETTER(State)(&floppyState);

switch (floppyState)

{

case DriveState_ImageMounted:

{

ComPtr<IFloppyImage> floppyImage;

rc = floppyDrive->GetImage(floppyImage.asOutParam());

if (SUCCEEDED(rc) && floppyImage)

{

Bstr imagePath;

floppyImage->COMGETTER(FilePath)(imagePath.asOutParam());

Guid imageGuid;

floppyImage->COMGETTER(Id)(imageGuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("FloppyImageUUID=\"%s\"\n", imageGuid.toString().raw());

pszFloppy = Utf8StrFmt("%lS", imagePath.raw());

}

else

pszFloppy = Utf8StrFmt("%lS (UUID: %s)", imagePath.raw(), imageGuid.toString().raw());

}

break;

}

case DriveState_HostDriveCaptured:

{

ComPtr<IHostFloppyDrive> hostFloppyDrive;

rc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam());

if (SUCCEEDED(rc) && floppyDrive)

{

Bstr driveName;

hostFloppyDrive->COMGETTER(Name)(driveName.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

pszFloppy = Utf8StrFmt("host:%lS", driveName.raw());

else

pszFloppy = Utf8StrFmt("Host drive %lS", driveName.raw());

}

break;

}

case DriveState_NotMounted:

{

pszFloppy = "empty";

break;

}

}

}

else

{

pszFloppy = "disabled";

}

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("floppy=\"%s\"\n", pszFloppy.raw());

else

RTPrintf("Floppy: %s\n", pszFloppy.raw());

}

/*

ComPtr<ISATAController> SATACtl;

rc = machine->COMGETTER(SATAController)(SATACtl.asOutParam());

if (SUCCEEDED(rc))

{

BOOL fEnabled;

rc = SATACtl->COMGETTER(Enabled)(&fEnabled);

if (FAILED(rc))

fEnabled = false;

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("sata=\"%s\"\n", fEnabled ? "on" : "off");

else

RTPrintf("SATA: %s\n", fEnabled ? "enabled" : "disabled");

}

/*

ComPtr<IHardDisk> hardDisk;

Bstr filePath;

rc = machine->GetHardDisk(StorageBus_IDE, 0, 0, hardDisk.asOutParam());

if (SUCCEEDED(rc) && hardDisk)

{

/// @todo (dmik) we temporarily use the location property to

// determine the image file name. This is subject to change

// when iSCSI disks are here (we should either query a

// storage-specific interface from IHardDisk, or "standardize"

// the location property)

hardDisk->COMGETTER(Location)(filePath.asOutParam());

hardDisk->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("hda=\"%lS\"\n", filePath.raw());

RTPrintf("HdaImageUUID=\"%s\"\n", uuid.toString().raw());

}

else

RTPrintf("Primary master: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("hda=\"none\"\n");

}

rc = machine->GetHardDisk(StorageBus_IDE, 0, 1, hardDisk.asOutParam());

if (SUCCEEDED(rc) && hardDisk)

{

/// @todo (dmik) we temporarily use the location property to

// determine the image file name. This is subject to change

// when iSCSI disks are here (we should either query a

// storage-specific interface from IHardDisk, or "standardize"

// the location property)

hardDisk->COMGETTER(Location)(filePath.asOutParam());

hardDisk->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("hdb=\"%lS\"\n", filePath.raw());

RTPrintf("HdbImageUUID=\"%s\"\n", uuid.toString().raw());

}

else

RTPrintf("Primary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("hdb=\"none\"\n");

}

rc = machine->GetHardDisk(StorageBus_IDE, 1, 1, hardDisk.asOutParam());

if (SUCCEEDED(rc) && hardDisk)

{

/// @todo (dmik) we temporarily use the location property to

// determine the image file name. This is subject to change

// when iSCSI disks are here (we should either query a

// storage-specific interface from IHardDisk, or "standardize"

// the location property)

hardDisk->COMGETTER(Location)(filePath.asOutParam());

hardDisk->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("hdd=\"%lS\"\n", filePath.raw());

RTPrintf("HddImageUUID=\"%s\"\n", uuid.toString().raw());

}

else

RTPrintf("Secondary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("hdd=\"none\"\n");

}

ComPtr<IDVDDrive> dvdDrive;

rc = machine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());

if (SUCCEEDED(rc) && dvdDrive)

{

ComPtr<IDVDImage> dvdImage;

rc = dvdDrive->GetImage(dvdImage.asOutParam());

if (SUCCEEDED(rc) && dvdImage)

{

rc = dvdImage->COMGETTER(FilePath)(filePath.asOutParam());

if (SUCCEEDED(rc) && filePath)

{

rc = dvdImage->COMGETTER(Id)(uuid.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("dvd=\"%lS\"\n", filePath.raw());

RTPrintf("DvdImageUUID=\"%s\"\n", uuid.toString().raw());

}

else

RTPrintf("DVD: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());

}

}

else

{

ComPtr<IHostDVDDrive> hostDVDDrive;

rc = dvdDrive->GetHostDrive(hostDVDDrive.asOutParam());

if (SUCCEEDED(rc) && hostDVDDrive)

{

Bstr name;

hostDVDDrive->COMGETTER(Name)(name.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("dvd=\"host:%lS\"\n", name.raw());

else

RTPrintf("DVD: Host drive %lS", name.raw());

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("dvd=\"none\"\n");

else

RTPrintf("DVD: empty");

}

BOOL fPassthrough;

dvdDrive->COMGETTER(Passthrough)(&fPassthrough);

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("dvdpassthrough=\"%s\"\n", fPassthrough ? "on" : "off");

}

else

{

if (fPassthrough)

RTPrintf(" (passthrough enabled)");

RTPrintf("\n");

}

}

}

/* get the maximum amount of NICS */

ComPtr<ISystemProperties> sysProps;

virtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam());

ULONG maxNICs = 0;

sysProps->COMGETTER(NetworkAdapterCount)(&maxNICs);

for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)

{

ComPtr<INetworkAdapter> nic;

rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());

if (SUCCEEDED(rc) && nic)

{

BOOL fEnabled;

nic->COMGETTER(Enabled)(&fEnabled);

if (!fEnabled)

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("nic%d=\"none\"\n", currentNIC + 1);

else

RTPrintf("NIC %d: disabled\n", currentNIC + 1);

}

else

{

Bstr strMACAddress;

nic->COMGETTER(MACAddress)(strMACAddress.asOutParam());

Utf8Str strAttachment;

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;

nic->COMGETTER(NATNetwork)(strNetwork.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("natnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());

strAttachment = "nat";

}

else if (!strNetwork.isEmpty())

strAttachment = Utf8StrFmt("NAT (%lS)", strNetwork.raw());

else

strAttachment = "NAT";

break;

}

case NetworkAttachmentType_HostInterface:

{

Bstr strHostIfDev;

nic->COMGETTER(HostInterface)(strHostIfDev.asOutParam());

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("hostifdev%d=\"%lS\"\n", currentNIC + 1, strHostIfDev.raw());

strAttachment = "hostif";

}

else

strAttachment = Utf8StrFmt("Host Interface '%lS'", strHostIfDev.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).raw());

break;

}

default:

strAttachment = "unknown";

break;

}

/* cable connected */

BOOL fConnected;

nic->COMGETTER(CableConnected)(&fConnected);

/* trace stuff */

BOOL fTraceEnabled;

nic->COMGETTER(TraceEnabled)(&fTraceEnabled);

Bstr traceFile;

nic->COMGETTER(TraceFile)(traceFile.asOutParam());

/* NIC type */

Utf8Str strNICType;

NetworkAdapterType_T NICType;

nic->COMGETTER(AdapterType)(&NICType);

switch (NICType) {

case NetworkAdapterType_Am79C970A:

strNICType = "Am79C970A";

break;

case NetworkAdapterType_Am79C973:

strNICType = "Am79C973";

break;

#ifdef VBOX_WITH_E1000

case NetworkAdapterType_I82540EM:

strNICType = "82540EM";

break;

case NetworkAdapterType_I82543GC:

strNICType = "82543GC";

break;

#endif

default:

strNICType = "unknown";

break;

}

/* reported line speed */

ULONG ulLineSpeed;

nic->COMGETTER(LineSpeed)(&ulLineSpeed);

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.raw());

}

else

RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Cable connected: %s, Trace: %s (file: %lS), Type: %s, Reported speed: %d Mbps\n",

currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),

fConnected ? "on" : "off",

fTraceEnabled ? "on" : "off",

traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),

strNICType.raw(),

ulLineSpeed / 1000);

}

}

}

/* 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)

{

BOOL fEnabled;

uart->COMGETTER(Enabled)(&fEnabled);

if (!fEnabled)

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("uart%d=\"off\"\n", currentUART + 1);

else

RTPrintf("UART %d: disabled\n", currentUART + 1);

}

else

{

ULONG ulIRQ, ulIOBase;

PortMode_T HostMode;

Bstr path;

BOOL fServer;

uart->COMGETTER(IRQ)(&ulIRQ);

uart->COMGETTER(IOBase)(&ulIOBase);

uart->COMGETTER(Path)(path.asOutParam());

uart->COMGETTER(Server)(&fServer);

uart->COMGETTER(HostMode)(&HostMode);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,

ulIOBase, ulIRQ);

else

RTPrintf("UART %d: I/O base: 0x%04x, IRQ: %d",

currentUART + 1, ulIOBase, ulIRQ);

switch (HostMode)

{

default:

case PortMode_Disconnected:

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);

else

RTPrintf(", disconnected\n");

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'\n",

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'\n", path.raw());

break;

}

}

}

}

ComPtr<IAudioAdapter> AudioAdapter;

rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());

if (SUCCEEDED(rc))

{

const char *pszDrv = "Unknown";

const char *pszCtrl = "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;

}

}

else

fEnabled = FALSE;

if (details == VMINFO_MACHINEREADABLE)

{

if (fEnabled)

RTPrintf("audio=\"%s\"\n", pszDrv);

else

RTPrintf("audio=\"none\"\n");

}

else

RTPrintf("Audio: %s (Driver: %s, Controller: %s)\n",

fEnabled ? "enabled" : "disabled", pszDrv, pszCtrl);

}

/* Shared clipboard */

{

const char *psz = "Unknown";

ClipboardMode_T enmMode;

rc = machine->COMGETTER(ClipboardMode)(&enmMode);

switch (enmMode)

{

case ClipboardMode_Disabled:

if (details == VMINFO_MACHINEREADABLE)

psz = "disabled";

else

psz = "disabled";

break;

case ClipboardMode_HostToGuest:

if (details == VMINFO_MACHINEREADABLE)

psz = "hosttoguest";

else

psz = "HostToGuest";

break;

case ClipboardMode_GuestToHost:

if (details == VMINFO_MACHINEREADABLE)

psz = "guesttohost";

else

psz = "GuestToHost";

break;

case ClipboardMode_Bidirectional:

if (details == VMINFO_MACHINEREADABLE)

psz = "bidirectional";

else

psz = "Bidirectional";

break;

default:

if (details == VMINFO_MACHINEREADABLE)

psz = "unknown";

break;

}

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("clipboard=\"%s\"\n", psz);

else

RTPrintf("Clipboard Mode: %s\n", psz);

}

if (console)

{

ComPtr<IDisplay> display;

CHECK_ERROR_RET(console, COMGETTER(Display)(display.asOutParam()), rc);

ULONG xRes, yRes, bpp;

CHECK_ERROR_RET(display, COMGETTER(Width)(&xRes), rc);

CHECK_ERROR_RET(display, COMGETTER(Height)(&yRes), rc);

CHECK_ERROR_RET(display, COMGETTER(BitsPerPixel)(&bpp), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VideoMode=\"%d,%d,%d\"\n", xRes, yRes, bpp);

else

RTPrintf("Video mode: %dx%dx%d\n", xRes, yRes, bpp);

}

/*

ComPtr<IVRDPServer> vrdpServer;

rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());

if (SUCCEEDED(rc) && vrdpServer)

{

BOOL fEnabled = false;

vrdpServer->COMGETTER(Enabled)(&fEnabled);

if (fEnabled)

{

ULONG port;

vrdpServer->COMGETTER(Port)(&port);

Bstr address;

vrdpServer->COMGETTER(NetAddress)(address.asOutParam());

BOOL fMultiCon;

vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);

VRDPAuthType_T vrdpAuthType;

const char *strAuthType;

vrdpServer->COMGETTER(AuthType)(&vrdpAuthType);

switch (vrdpAuthType)

{

case VRDPAuthType_Null:

strAuthType = "null";

break;

case VRDPAuthType_External:

strAuthType = "external";

break;

case VRDPAuthType_Guest:

strAuthType = "guest";

break;

default:

strAuthType = "unknown";

break;

}

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("vrdp=\"on\"\n");

RTPrintf("vrdpport=%d\n", port);

RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());

RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);

RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");

}

else

{

if (address.isEmpty())

address = "0.0.0.0";

RTPrintf("VRDP: enabled (Address %lS, Port %d, MultiConn: %s, Authentication type: %s)\n", address.raw(), port, fMultiCon ? "on" : "off", strAuthType);

}

}

else

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("vrdp=\"off\"\n");

else

RTPrintf("VRDP: disabled\n");

}

}

/*

ComPtr<IUSBController> USBCtl;

rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());

if (SUCCEEDED(rc))

{

BOOL fEnabled;

rc = USBCtl->COMGETTER(Enabled)(&fEnabled);

if (FAILED(rc))

fEnabled = false;

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");

else

RTPrintf("USB: %s\n", fEnabled ? "enabled" : "disabled");

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\nUSB Device Filters:\n\n");

ComPtr<IUSBDeviceFilterCollection> Coll;

CHECK_ERROR_RET (USBCtl, COMGETTER(DeviceFilters)(Coll.asOutParam()), rc);

ComPtr<IUSBDeviceFilterEnumerator> Enum;

CHECK_ERROR_RET (Coll, Enumerate(Enum.asOutParam()), rc);

ULONG index = 0;

BOOL fMore = FALSE;

rc = Enum->HasMore (&fMore);

ASSERT_RET (SUCCEEDED (rc), rc);

if (!fMore)

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("<none>\n\n");

}

else

while (fMore)

{

ComPtr<IUSBDeviceFilter> DevPtr;

rc = Enum->GetNext(DevPtr.asOutParam());

ASSERT_RET (SUCCEEDED (rc), rc);

/* Query info. */

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("Index: %lu\n", index);

BOOL bActive = FALSE;

CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterActive%d=\"%s\"\n", index + 1, bActive ? "on" : "off");

else

RTPrintf("Active: %s\n", bActive ? "yes" : "no");

Bstr bstr;

CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterName%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Name: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterVendorId%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("VendorId: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterProductId%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("ProductId: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterRevision%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Revision: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Manufacturer: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterProduct%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Product: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterRemote%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Remote: %lS\n", bstr.raw());

CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBFilterSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Serial Number: %lS\n", bstr.raw());

if (details != VMINFO_MACHINEREADABLE)

{

ULONG fMaskedIfs;

CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);

if (fMaskedIfs)

RTPrintf("Masked Interfaces: 0x%08x\n", fMaskedIfs);

RTPrintf("\n");

}

rc = Enum->HasMore (&fMore);

ASSERT_RET (SUCCEEDED (rc), rc);

index ++;

}

if (console)

{

index = 0;

/* scope */

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("Available remote USB devices:\n\n");

ComPtr<IHostUSBDeviceCollection> coll;

CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (coll.asOutParam()), rc);

ComPtr <IHostUSBDeviceEnumerator> en;

CHECK_ERROR_RET (coll, Enumerate (en.asOutParam()), rc);

BOOL more = FALSE;

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

if (!more)

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("<none>\n\n");

}

else

while (more)

{

ComPtr <IHostUSBDevice> dev;

rc = en->GetNext (dev.asOutParam());

ASSERT_RET (SUCCEEDED (rc), rc);

/* Query info. */

Guid id;

CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);

USHORT usVendorId;

CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);

USHORT usProductId;

CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);

USHORT bcdRevision;

CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBRemoteUUID%d=\"%S\"\n"

"USBRemoteVendorId%d=\"%#06x\"\n"

"USBRemoteProductId%d=\"%#06x\"\n"

"USBRemoteRevision%d=\"%#04x%02x\"\n",

index + 1, id.toString().raw(),

index + 1, usVendorId,

index + 1, usProductId,

index + 1, bcdRevision >> 8, bcdRevision & 0xff);

else

RTPrintf("UUID: %S\n"

"VendorId: 0x%04x (%04X)\n"

"ProductId: 0x%04x (%04X)\n"

"Revision: %u.%u (%02u%02u)\n",

id.toString().raw(),

usVendorId, usVendorId, usProductId, usProductId,

bcdRevision >> 8, bcdRevision & 0xff,

bcdRevision >> 8, bcdRevision & 0xff);

/* optional stuff. */

Bstr bstr;

CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBRemoteManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Manufacturer: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBRemoteProduct%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Product: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBRemoteSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("SerialNumber: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBRemoteAddress%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Address: %lS\n", bstr.raw());

}

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

index ++;

}

}

index = 0;

/* scope */

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf ("Currently Attached USB Devices:\n\n");

ComPtr <IUSBDeviceCollection> coll;

CHECK_ERROR_RET (console, COMGETTER(USBDevices) (coll.asOutParam()), rc);

ComPtr <IUSBDeviceEnumerator> en;

CHECK_ERROR_RET (coll, Enumerate (en.asOutParam()), rc);

BOOL more = FALSE;

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

if (!more)

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("<none>\n\n");

}

else

while (more)

{

ComPtr <IUSBDevice> dev;

rc = en->GetNext (dev.asOutParam());

ASSERT_RET (SUCCEEDED (rc), rc);

/* Query info. */

Guid id;

CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);

USHORT usVendorId;

CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);

USHORT usProductId;

CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);

USHORT bcdRevision;

CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBAttachedUUID%d=\"%S\"\n"

"USBAttachedVendorId%d=\"%#06x\"\n"

"USBAttachedProductId%d=\"%#06x\"\n"

"USBAttachedRevision%d=\"%#04x%02x\"\n",

index + 1, id.toString().raw(),

index + 1, usVendorId,

index + 1, usProductId,

index + 1, bcdRevision >> 8, bcdRevision & 0xff);

else

RTPrintf("UUID: %S\n"

"VendorId: 0x%04x (%04X)\n"

"ProductId: 0x%04x (%04X)\n"

"Revision: %u.%u (%02u%02u)\n",

id.toString().raw(),

usVendorId, usVendorId, usProductId, usProductId,

bcdRevision >> 8, bcdRevision & 0xff,

bcdRevision >> 8, bcdRevision & 0xff);

/* optional stuff. */

Bstr bstr;

CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBAttachedManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Manufacturer: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBAttachedProduct%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Product: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBAttachedSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("SerialNumber: %lS\n", bstr.raw());

}

CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);

if (!bstr.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("USBAttachedAddress%d=\"%lS\"\n", index + 1, bstr.raw());

else

RTPrintf("Address: %lS\n", bstr.raw());

}

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

index ++;

}

}

}

} /* USB */

/*

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("Shared folders: ");

uint32_t numSharedFolders = 0;

#if 0 // not yet implemented

/* globally shared folders first */

{

ComPtr<ISharedFolderCollection> sfColl;

ComPtr<ISharedFolderEnumerator> sfEnum;

CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);

CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);

BOOL fMore;

sfEnum->HasMore(&fMore);

while (fMore)

{

ComPtr<ISharedFolder> sf;

CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);

Bstr name, hostPath;

sf->COMGETTER(Name)(name.asOutParam());

sf->COMGETTER(HostPath)(hostPath.asOutParam());

RTPrintf("Name: '%lS', Host path: '%lS' (global mapping)\n", name.raw(), hostPath.raw());

++numSharedFolders;

CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);

}

}

#endif

/* now VM mappings */

{

ComPtr<ISharedFolderCollection> sfColl;

ComPtr<ISharedFolderEnumerator> sfEnum;

CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);

CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);

ULONG index = 0;

BOOL fMore;

sfEnum->HasMore(&fMore);

while (fMore)

{

ComPtr<ISharedFolder> sf;

CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);

Bstr name, hostPath;

BOOL writable;

sf->COMGETTER(Name)(name.asOutParam());

sf->COMGETTER(HostPath)(hostPath.asOutParam());

sf->COMGETTER(Writable)(&writable);

if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)

RTPrintf("\n\n");

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("SharedFolderNameMachineMapping%d=\"%lS\"\n", index + 1,

name.raw());

RTPrintf("SharedFolderPathMachineMapping%d=\"%lS\"\n", index + 1,

hostPath.raw());

}

else

RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",

name.raw(), hostPath.raw(), writable ? "writable" : "readonly");

++numSharedFolders;

CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);

}

}

/* transient mappings */

if (console)

{

ComPtr<ISharedFolderCollection> sfColl;

ComPtr<ISharedFolderEnumerator> sfEnum;

CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);

CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);

ULONG index = 0;

BOOL fMore;

sfEnum->HasMore(&fMore);

while (fMore)

{

ComPtr<ISharedFolder> sf;

CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);

Bstr name, hostPath;

sf->COMGETTER(Name)(name.asOutParam());

sf->COMGETTER(HostPath)(hostPath.asOutParam());

if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)

RTPrintf("\n\n");

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("SharedFolderNameTransientMapping%d=\"%lS\"\n", index + 1,

name.raw());

RTPrintf("SharedFolderPathTransientMapping%d=\"%lS\"\n", index + 1,

hostPath.raw());

}

else

RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());

++numSharedFolders;

CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);

}

}

if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)

RTPrintf("<none>\n");

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

if (console)

{

/*

ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;

CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);

BOOL Active;

ULONG NumberOfClients;

LONG64 BeginTime;

LONG64 EndTime;

ULONG64 BytesSent;

ULONG64 BytesSentTotal;

ULONG64 BytesReceived;

ULONG64 BytesReceivedTotal;

Bstr User;

Bstr Domain;

Bstr ClientName;

Bstr ClientIP;

ULONG ClientVersion;

ULONG EncryptionStyle;

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active) (&Active), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients) (&NumberOfClients), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime) (&BeginTime), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime) (&EndTime), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent) (&BytesSent), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal) (&BytesSentTotal), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived) (&BytesReceived), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User) (User.asOutParam ()), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain) (Domain.asOutParam ()), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName) (ClientName.asOutParam ()), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP) (ClientIP.asOutParam ()), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion) (&ClientVersion), rc);

CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle) (&EncryptionStyle), rc);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VRDPActiveConnection=\"%s\"\n", Active ? "on": "off");

else

RTPrintf("VRDP Connection: %s\n", Active? "active": "not active");

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VRDPClients=%d\n", NumberOfClients);

else

RTPrintf("Clients so far: %d\n", NumberOfClients);

if (NumberOfClients > 0)

{

char timestr[128];

if (Active)

{

makeTimeStr (timestr, sizeof (timestr), BeginTime);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VRDPStartTime=\"%s\"\n", timestr);

else

RTPrintf("Start time: %s\n", timestr);

}

else

{

makeTimeStr (timestr, sizeof (timestr), BeginTime);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);

else

RTPrintf("Last started: %s\n", timestr);

makeTimeStr (timestr, sizeof (timestr), EndTime);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);

else

RTPrintf("Last ended: %s\n", timestr);

}

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("VRDPBytesSent=%llu\n", BytesSent);

RTPrintf("VRDPThroughputSend=%llu\n", (BytesSent * 1000) / (EndTime - BeginTime) );

RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);

RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);

RTPrintf("VRDPThroughputReceive=%llu\n", (BytesReceived * 1000) / (EndTime - BeginTime) );

RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);

}

else

{

RTPrintf("Sent: %llu Bytes\n", BytesSent);

RTPrintf("Average speed: %llu B/s\n", (BytesSent * 1000) / (EndTime - BeginTime) );

RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);

RTPrintf("Received: %llu Bytes\n", BytesReceived);

RTPrintf("Speed: %llu B/s\n", (BytesReceived * 1000) / (EndTime - BeginTime) );

RTPrintf("Received total: %llu Bytes\n", BytesReceivedTotal);

}

if (Active)

{

if (details == VMINFO_MACHINEREADABLE)

{

RTPrintf("VRDPUserName=\"%lS\"\n", User.raw());

RTPrintf("VRDPDomain=\"%lS\"\n", Domain.raw());

RTPrintf("VRDPClientName=\"%lS\"\n", ClientName.raw());

RTPrintf("VRDPClientIP=\"%lS\"\n", ClientIP.raw());

RTPrintf("VRDPClientVersion=%d\n", ClientVersion);

RTPrintf("VRDPEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");

}

else

{

RTPrintf("User name: %lS\n", User.raw());

RTPrintf("Domain: %lS\n", Domain.raw());

RTPrintf("Client name: %lS\n", ClientName.raw());

RTPrintf("Client IP: %lS\n", ClientIP.raw());

RTPrintf("Client version: %d\n", ClientVersion);

RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");

}

}

}

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

}

if ( details == VMINFO_STANDARD

|| details == VMINFO_FULL

|| details == VMINFO_MACHINEREADABLE)

{

Bstr description;

machine->COMGETTER(Description)(description.asOutParam());

if (!description.isEmpty())

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("description=\"%lS\"\n", description.raw());

else

RTPrintf("Description:\n%lS\n", description.raw());

}

}

ULONG guestVal;

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("Guest:\n\n");

#ifdef VBOX_WITH_MEM_BALLOONING

rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("GuestMemoryBalloon=%d\n", guestVal);

else

RTPrintf("Configured memory balloon size: %d MB\n", guestVal);

}

#endif

rc = machine->COMGETTER(StatisticsUpdateInterval)(&guestVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("GuestStatisticsUpdateInterval=%d\n", guestVal);

else

{

if (guestVal == 0)

RTPrintf("Statistics update: disabled\n");

else

RTPrintf("Statistics update interval: %d seconds\n", guestVal);

}

}

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

if ( console

&& ( details == VMINFO_STATISTICS

|| details == VMINFO_FULL

|| details == VMINFO_MACHINEREADABLE))

{

ComPtr <IGuest> guest;

rc = console->COMGETTER(Guest)(guest.asOutParam());

if (SUCCEEDED(rc))

{

ULONG statVal;

rc = guest->GetStatistic(0, GuestStatisticType_SampleNumber, &statVal);

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestSample=%d\n", statVal);

else

RTPrintf("Guest statistics for sample %d:\n\n", statVal);

rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Idle, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestLoadIdleCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: CPU Load Idle %-3d%%\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Kernel, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestLoadKernelCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: CPU Load Kernel %-3d%%\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_User, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestLoadUserCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: CPU Load User %-3d%%\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_Threads, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestThreadsCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Threads %d\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_Processes, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestProcessesCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Processes %d\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_Handles, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestHandlesCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Handles %d\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_MemoryLoad, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryLoadCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Memory Load %d%%\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_PhysMemTotal, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryTotalPhysCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Total physical memory %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_PhysMemAvailable, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryFreePhysCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Free physical memory %-4d MB\n", 0, statVal);

}

#ifdef VBOX_WITH_MEM_BALLOONING

rc = guest->GetStatistic(0, GuestStatisticType_PhysMemBalloon, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryBalloonCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Memory balloon size %-4d MB\n", 0, statVal);

}

#endif

rc = guest->GetStatistic(0, GuestStatisticType_MemCommitTotal, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryCommittedCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Committed memory %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_MemKernelTotal, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryTotalKernelCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Total kernel memory %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_MemKernelPaged, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryPagedKernelCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Paged kernel memory %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_MemKernelNonpaged, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestMemoryNonpagedKernelCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Nonpaged kernel memory %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_MemSystemCache, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestSystemCacheSizeCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: System cache size %-4d MB\n", 0, statVal);

}

rc = guest->GetStatistic(0, GuestStatisticType_PageFileSize, &statVal);

if (SUCCEEDED(rc))

{

if (details == VMINFO_MACHINEREADABLE)

RTPrintf("StatGuestPageFileSizeCPU%d=%d\n", 0, statVal);

else

RTPrintf("CPU%d: Page file size %-4d MB\n", 0, statVal);

}

RTPrintf("\n");

}

else

{

if (details != VMINFO_MACHINEREADABLE)

{

RTPrintf("[!] FAILED calling console->getGuest at line %d!\n", __LINE__);

PRINT_RC_MESSAGE(rc);

}

}

}

/*

ComPtr<ISnapshot> snapshot;

rc = machine->GetSnapshot(Guid(), snapshot.asOutParam());

if (SUCCEEDED(rc) && snapshot)

{

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("Snapshots:\n\n");

showSnapshots(snapshot, details);

}

if (details != VMINFO_MACHINEREADABLE)

RTPrintf("\n");

return S_OK;

}

static int handleShowVMInfo(int argc, char *argv[],

ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)

{

HRESULT rc;

/* at least one option: the UUID or name of the VM */

if (argc < 1)

return errorSyntax(USAGE_SHOWVMINFO, "Incorrect number of parameters");

/* try to find the given machine */

ComPtr <IMachine> machine;

Guid uuid (argv[0]);

if (!uuid.isEmpty())

{

CHECK_ERROR (virtualBox, GetMachine (uuid, machine.asOutParam()));

}

else

{

CHECK_ERROR (virtualBox, FindMachine (Bstr(argv[0]), machine.asOutParam()));

if (SUCCEEDED (rc))

machine->COMGETTER(Id) (uuid.asOutParam());

}

if (FAILED (rc))

return 1;

/* 2nd option can be -details, -statistics or -argdump */

VMINFO_DETAILS details = VMINFO_NONE;

bool fDetails = false;

bool fStatistics = false;

bool fMachinereadable = false;

for (int i=1;i<argc;i++)

{

if (!strcmp(argv[i], "-details"))

fDetails = true;

else

if (!strcmp(argv[i], "-statistics"))

fStatistics = true;

if (!strcmp(argv[1], "-machinereadable"))

fMachinereadable = true;

}

if (fMachinereadable)

details = VMINFO_MACHINEREADABLE;

else

if (fDetails && fStatistics)

details = VMINFO_FULL;

else

if (fDetails)

details = VMINFO_STANDARD;

else

if (fStatistics)

details = VMINFO_STATISTICS;

ComPtr <IConsole> console;

/* open an existing session for the VM */

rc = virtualBox->OpenExistingSession (session, uuid);

if (SUCCEEDED(rc))

/* get the session machine */

rc = session->COMGETTER(Machine)(machine.asOutParam());

if (SUCCEEDED(rc))

/* get the session console */

rc = session->COMGETTER(Console)(console.asOutParam());

rc = showVMInfo (virtualBox, machine, console, details);

if (console)

session->Close();

return SUCCEEDED (rc) ? 0 : 1;

}

static int handleList(int argc, char *argv[],

ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)

{

HRESULT rc = S_OK;

/* exactly one option: the object */

if (argc != 1)

return errorSyntax(USAGE_LIST, "Incorrect number of parameters");

/* which object? */

if (strcmp(argv[0], "vms") == 0)

{

/*

ComPtr<IMachineCollection> collection;

rc = virtualBox->COMGETTER(Machines)(collection.asOutParam());

ComPtr<IMachineEnumerator> enumerator;

if (SUCCEEDED(rc))

rc = collection->Enumerate(enumerator.asOutParam());

if (SUCCEEDED(rc))

{

/*

BOOL hasMore = FALSE;

while (enumerator->HasMore(&hasMore), hasMore)

{

ComPtr<IMachine> machine;

rc = enumerator->GetNext(machine.asOutParam());

if ((SUCCEEDED(rc)) && machine)

{

rc = showVMInfo(virtualBox, machine);

}

}

}

}

else

if (strcmp(argv[0], "runningvms") == 0)

{

/*

ComPtr<IMachineCollection> collection;

rc = virtualBox->COMGETTER(Machines)(collection.asOutParam());

ComPtr<IMachineEnumerator> enumerator;

if (SUCCEEDED(rc))

rc = collection->Enumerate(enumerator.asOutParam());

if (SUCCEEDED(rc))

{

/*

BOOL hasMore = FALSE;

while (enumerator->HasMore(&hasMore), hasMore)

{

ComPtr<IMachine> machine;

rc = enumerator->GetNext(machine.asOutParam());

if ((SUCCEEDED(rc)) && machine)

{

MachineState_T machineState;

rc = machine->COMGETTER(State)(&machineState);

if (SUCCEEDED(rc))

{

switch (machineState)

{

case MachineState_Running:

case MachineState_Paused:

{

Guid uuid;

rc = machine->COMGETTER(Id) (uuid.asOutParam());

if (SUCCEEDED(rc))

RTPrintf ("%s\n", uuid.toString().raw());

break;

}

}

}

}

}

}

}

else

if (strcmp(argv[0], "ostypes") == 0)

{

ComPtr<IGuestOSTypeCollection> coll;

ComPtr<IGuestOSTypeEnumerator> enumerator;

CHECK_ERROR(virtualBox, COMGETTER(GuestOSTypes)(coll.asOutParam()));