#include <VBox/com/com.h>

#include <VBox/com/string.h>

#include <VBox/com/Guid.h>

#include <VBox/com/ErrorInfo.h>

#include <VBox/com/EventQueue.h>

#include <VBox/com/VirtualBox.h>

#define CFGLDR_HAVE_COM

#include <VBox/cfgldr.h>

#include <stdlib.h>

#include <stdarg.h>

#include <vector>

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

#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_InvalidUSBDeviceFilterAction)

{}

Bstr mName;

Nullable <bool> mActive;

Bstr mVendorId;

Bstr mProductId;

Bstr mRevision;

Bstr mManufacturer;

Bstr mProduct;

Bstr mRemote;

Bstr mSerialNumber;

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 printUsage(USAGECATEGORY u64Cmd)

{

#ifdef __LINUX__

bool fLinux = true;

#else

bool fLinux = false;

#endif

#ifdef __WIN__

bool fWin = true;

#else

bool fWin = false;

#endif

#ifdef __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;

fVRDP = true;

u64Cmd = USAGE_ALL;

}

RTPrintf("Usage:\n"

"\n");

if (u64Cmd & USAGE_LIST)

{

RTPrintf("VBoxManage list vms|ostypes|hostdvds|hostfloppies|");

if (fWin)

RTPrintf( "hostifs|");

RTPrintf( "\n"

" hdds|dvds|floppies|usbhost|usbfilters|\n"

" systemproperties\n"

"\n");

}

if (u64Cmd & USAGE_SHOWVMINFO)

{

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

" [-details]\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"

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

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

" [-bioslogofadein on|off]\n"

" [-bioslogofadeout on|off]\n"

" [-bioslogodisplaytime <msec>]\n"

" [-bioslogoimagepath <imagepath>]\n"

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

" [-biossystemtimeoffset <msec>]\n"

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

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

" [-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]\n"

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

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

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

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

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

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

if (fLinux)

{

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

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

}

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

if (fWin)

{

RTPrintf( "|winmm|dsound");

}

if (fLinux)

{

RTPrintf( "|oss"

#ifdef VBOX_WITH_ALSA

"|alsa"

#endif

);

}

if (fDarwin)

{

RTPrintf( "|coreaudio");

}

RTPrintf( "]\n");

RTPrintf(" [-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"

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

"\n");

}

if (u64Cmd & USAGE_STARTVM)

{

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

" [-type gui|vrdp]\n"

"\n");

}

if (u64Cmd & USAGE_CONTROLVM)

{

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

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

" acpipowerbutton |\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> |\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_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 <filename> <outputfile>\n"

"VBoxManage convertdd 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"

" hwvirtexenabled yes|no\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"

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

"\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]\n"

"\n");

}

if (u64Cmd & USAGE_SHAREDFOLDER_REMOVE)

{

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

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

"\n");

}

if (u64Cmd & USAGE_UPDATESETTINGS)

{

RTPrintf("VBoxManage updatesettings [<dir>|<file>] [-apply]\n"

" [-nobackup] [-skipinvalid]\n"

"\n");

}

}

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

{

va_list args;

if (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, 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;

if (fCompleted)

{

RTPrintf("100%%\n");

RTStrmFlush(g_pStdOut);

break;

}

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

RTThreadSleep(100);

}

}

static void showSnapshots(ComPtr<ISnapshot> rootSnapshot, int level = 0)

{

/* start with the root */

Bstr name;

Guid uuid;

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

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

/* print with indentation */

RTPrintf("%*sName: %lS (UUID: %s)\n", level * 3, "", 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());

BOOL hasMore = FALSE;

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

{

ComPtr<ISnapshot> snapshot;

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

if (snapshot)

{

/* recursive call */

showSnapshots(snapshot, level + 1);

}

}

}

}

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> (),

bool fDetails = false)

{

HRESULT rc;

BOOL accessible = FALSE;

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

CheckComRCReturnRC (rc);

if (!accessible)

{

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

Guid uuid;

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

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

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

ei.print ("[-] ");

RTPrintf ("\n");

return S_OK;

}

Bstr machineName;

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

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

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

Guid uuid;

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

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

Bstr settingsFilePath;

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

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

ULONG memorySize;

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

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

ULONG vramSize;

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

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

ComPtr <IBIOSSettings> biosSettings;

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

BIOSBootMenuMode_T bootMenuMode;

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

RTPrintf("Boot menu mode: ");

switch (bootMenuMode)

{

case BIOSBootMenuMode_Disabled:

RTPrintf("disabled\n");

break;

case BIOSBootMenuMode_MenuOnly:

RTPrintf("menu only\n");

break;

default:

RTPrintf("message and menu\n");

}

BOOL acpiEnabled;

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

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

BOOL ioapicEnabled;

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

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

LONG64 timeOffset;

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

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

TriStateBool_T hwVirtExEnabled;

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

if (hwVirtExEnabled == TriStateBool_Default)

{

BOOL fHWVirtExEnabled;

ComPtr<ISystemProperties> systemProperties;

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

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

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

}

else

{

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

}

MachineState_T machineState;

const char *pszState = NULL;

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

switch (machineState)

{

case MachineState_PoweredOff:

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

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

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

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

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

}

break;

}

case DriveState_NotMounted:

{

pszFloppy = "empty";

break;

}

}

}

else

{

pszFloppy = "disabled";

}

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

}

ComPtr<IHardDisk> hardDisk;

Bstr filePath;

rc = machine->GetHardDisk(DiskControllerType_IDE0Controller, 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());

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

}

rc = machine->GetHardDisk(DiskControllerType_IDE0Controller, 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());

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

}

rc = machine->GetHardDisk(DiskControllerType_IDE1Controller, 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());

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

}

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

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

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

}

else

RTPrintf("DVD: empty");

BOOL fPassthrough;

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

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)

{

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_NoNetworkAttachment:

strAttachment = "none";

break;

case NetworkAttachmentType_NATNetworkAttachment:

strAttachment = "NAT";

break;

case NetworkAttachmentType_HostInterfaceNetworkAttachment:

strAttachment = "Host Interface";

break;

case NetworkAttachmentType_InternalNetworkAttachment:

{

Bstr strNetwork;

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

strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).raw());

break;

}

default:

strAttachment = "unknown";

break;

}

/* trace stuff */

BOOL fTraceEnabled;

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

Bstr traceFile;

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

RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Trace: %s (file: %lS)\n",

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

fTraceEnabled ? "on" : "off", traceFile.raw());

}

}

}

ComPtr<IAudioAdapter> AudioAdapter;

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

if (SUCCEEDED(rc))

{

const char *psz = "Unknown";

BOOL fEnabled;

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

if (SUCCEEDED(rc) && fEnabled)

{

AudioDriverType_T enmType;

rc = AudioAdapter->COMGETTER(AudioDriver)(&enmType);

switch (enmType)

{

case AudioDriverType_NullAudioDriver: psz = "Null"; break;

case AudioDriverType_WINMMAudioDriver: psz = "WINMM"; break;

case AudioDriverType_DSOUNDAudioDriver: psz = "DSOUND"; break;

case AudioDriverType_OSSAudioDriver: psz = "OSS"; break;

case AudioDriverType_ALSAAudioDriver: psz = "ALSA"; break;

case AudioDriverType_CoreAudioDriver: psz = "CoreAudio"; break;

default: ; break;

}

}

else

fEnabled = FALSE;

RTPrintf("Audio: %s (Driver: %s)\n", fEnabled ? "enabled" : "disabled", psz);

}

/* Shared clipboard */

{

const char *psz = "Unknown";

ClipboardMode_T enmMode;

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

switch (enmMode)

{

case ClipboardMode_ClipDisabled: psz = "Disabled"; break;

case ClipboardMode_ClipHostToGuest: psz = "HostToGuest"; break;

case ClipboardMode_ClipGuestToHost: psz = "GuestToHost"; break;

case ClipboardMode_ClipBidirectional: psz = "Bidirectional"; break;

default: ; break;

}

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(ColorDepth)(&bpp), rc);

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

VRDPAuthType_T vrdpAuthType;

const char *strAuthType;

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

switch (vrdpAuthType)

{

case VRDPAuthType_VRDPAuthNull:

strAuthType = "null";

break;

case VRDPAuthType_VRDPAuthExternal:

strAuthType = "external";

break;

case VRDPAuthType_VRDPAuthGuest:

strAuthType = "guest";

break;

default:

strAuthType = "unknown";

break;

}

RTPrintf("VRDP: enabled (Port %d, Authentication type: %s)\n", port, strAuthType);

}

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;

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

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)

{

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

}

else

while (fMore)

{

ComPtr<IUSBDeviceFilter> DevPtr;

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

ASSERT_RET (SUCCEEDED (rc), rc);

/* Query info. */

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

BOOL bActive = FALSE;

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

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

Bstr bstr;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rc = Enum->HasMore (&fMore);

ASSERT_RET (SUCCEEDED (rc), rc);

index ++;

}

if (console)

{

/* scope */

{

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)

{

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

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

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

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

if (!bstr.isEmpty())

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

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

if (!bstr.isEmpty())

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

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

if (!bstr.isEmpty())

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

RTPrintf("\n");

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

}

}

/* scope */

{

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)

{

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

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

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

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

if (!bstr.isEmpty())

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

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

if (!bstr.isEmpty())

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

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

if (!bstr.isEmpty())

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

RTPrintf("\n");

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), rc);

}

}

}

} /* USB */

/*

RTPrintf("Shared folders:\n\n");

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

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' (machine mapping)\n", name.raw(), hostPath.raw());

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

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' (transient mapping)\n", name.raw(), hostPath.raw());

++numSharedFolders;

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

}

}

if (!numSharedFolders)

RTPrintf("<none>\n");

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

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

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

if (NumberOfClients > 0)

{

char timestr[128];

if (Active)

{

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

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

}

else

{

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

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

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

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

}

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)

{

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

}

}

RTPrintf("\n");

}

if (fDetails)

{

Bstr description;

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

if (!description.isEmpty())

{

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

}

}

/*

ComPtr<ISnapshot> snapshot;

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

if (SUCCEEDED(rc) && snapshot)

{

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

showSnapshots(snapshot);

}

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

bool fDetails = false;

if ((argc == 2) && !strcmp(argv[1], "-details"))

fDetails = true;

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

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], "ostypes") == 0)

{

ComPtr<IGuestOSTypeCollection> coll;

ComPtr<IGuestOSTypeEnumerator> enumerator;

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

if (SUCCEEDED(rc) && coll)

{

CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IGuestOSType> guestOS;

CHECK_RC_BREAK(enumerator->GetNext(guestOS.asOutParam()));

Bstr guestId;

guestOS->COMGETTER(Id)(guestId.asOutParam());

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

Bstr guestDescription;

guestOS->COMGETTER(Description)(guestDescription.asOutParam());

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

}

}

}

else

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

{

ComPtr<IHost> host;

CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));

ComPtr<IHostDVDDriveCollection> coll;

ComPtr<IHostDVDDriveEnumerator> enumerator;

CHECK_ERROR(host, COMGETTER(DVDDrives)(coll.asOutParam()));

if (SUCCEEDED(rc) && coll)

{

CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IHostDVDDrive> dvdDrive;

CHECK_RC_BREAK(enumerator->GetNext(dvdDrive.asOutParam()));

Bstr name;

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

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

}

}

}

else

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

{

ComPtr<IHost> host;

CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));

ComPtr<IHostFloppyDriveCollection> coll;

ComPtr<IHostFloppyDriveEnumerator> enumerator;

CHECK_ERROR(host, COMGETTER(FloppyDrives)(coll.asOutParam()));

if (SUCCEEDED(rc) && coll)

{

CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IHostFloppyDrive> floppyDrive;

CHECK_RC_BREAK(enumerator->GetNext(floppyDrive.asOutParam()));

Bstr name;

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

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

}

}

}

#ifdef __WIN__

else

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

{

ComPtr<IHost> host;

CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));

ComPtr<IHostNetworkInterfaceCollection> coll;

ComPtr<IHostNetworkInterfaceEnumerator> enumerator;

CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(coll.asOutParam()));

if (SUCCEEDED(rc) && coll)

{

CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IHostNetworkInterface> networkInterface;

CHECK_RC_BREAK(enumerator->GetNext(networkInterface.asOutParam()));

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

}

}

}

#endif /* __WIN__ */

else

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

{

ComPtr<IHardDiskCollection> hddColl;

CHECK_ERROR(virtualBox, COMGETTER(HardDisks)(hddColl.asOutParam()));

ComPtr<IHardDiskEnumerator> enumerator;

CHECK_ERROR(hddColl, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IHardDisk> hdd;

CHECK_RC_BREAK(enumerator->GetNext(hdd.asOutParam()));

Guid uuid;

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

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

HardDiskStorageType_T storageType;

hdd->COMGETTER(StorageType)(&storageType);

const char *storageTypeString = "unknown";

switch (storageType)

{

case HardDiskStorageType_VirtualDiskImage:

storageTypeString = "Virtual Disk Image";

break;

case HardDiskStorageType_ISCSIHardDisk:

storageTypeString = "iSCSI hard disk";

break;

}

RTPrintf("Storage type: %s\n", storageTypeString);

Bstr filepath;

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

hdd->COMGETTER(Location)(filepath.asOutParam());

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

BOOL fAccessible;

hdd->COMGETTER(AllAccessible)(&fAccessible);

RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");

Guid machineUUID;

hdd->COMGETTER(MachineId)(machineUUID.asOutParam());

if (!machineUUID.isEmpty())

{

ComPtr<IMachine> machine;

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

ASSERT(machine);

Bstr name;

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

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

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

}

RTPrintf("\n");

}

}

else

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

{

ComPtr<IDVDImageCollection> dvdColl;

CHECK_ERROR(virtualBox, COMGETTER(DVDImages)(dvdColl.asOutParam()));

ComPtr<IDVDImageEnumerator> enumerator;

CHECK_ERROR(dvdColl, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IDVDImage> dvdImage;

CHECK_RC_BREAK(enumerator->GetNext(dvdImage.asOutParam()));

Guid uuid;

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

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

Bstr filePath;

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

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

BOOL fAccessible;

dvdImage->COMGETTER(Accessible)(&fAccessible);

RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");

Bstr machineUUIDs;

CHECK_ERROR(virtualBox, GetDVDImageUsage(uuid, ResourceUsage_AllUsage, machineUUIDs.asOutParam()));

/** @todo usage */

RTPrintf("\n");

}

}

else

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

{

ComPtr<IFloppyImageCollection> floppyColl;

CHECK_ERROR(virtualBox, COMGETTER(FloppyImages)(floppyColl.asOutParam()));

ComPtr<IFloppyImageEnumerator> enumerator;

CHECK_ERROR(floppyColl, Enumerate(enumerator.asOutParam()));

BOOL hasMore;

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

{

ComPtr<IFloppyImage> floppyImage;

CHECK_RC_BREAK(enumerator->GetNext(floppyImage.asOutParam()));

Guid uuid;

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

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

Bstr filePath;

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

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

BOOL fAccessible;

floppyImage->COMGETTER(Accessible)(&fAccessible);

RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");

Bstr machineUUIDs;

CHECK_ERROR(virtualBox, GetFloppyImageUsage(uuid, ResourceUsage_AllUsage, machineUUIDs.asOutParam()));

/** @todo usage */

RTPrintf("\n");

}

}

else

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

{

ComPtr<IHost> Host;

CHECK_ERROR_RET (virtualBox, COMGETTER(Host)(Host.asOutParam()), 1);

ComPtr<IHostUSBDeviceCollection> CollPtr;

CHECK_ERROR_RET (Host, COMGETTER(USBDevices)(CollPtr.asOutParam()), 1);

ComPtr<IHostUSBDeviceEnumerator> EnumPtr;

CHECK_ERROR_RET (CollPtr, Enumerate(EnumPtr.asOutParam()), 1);

RTPrintf("Host USB Devices:\n\n");

BOOL fMore = FALSE;

rc = EnumPtr->HasMore (&fMore);

ASSERT_RET (SUCCEEDED (rc), 1);

if (!fMore)

{

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

}

else

while (fMore)

{

ComPtr <IHostUSBDevice> dev;

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

ASSERT_RET (SUCCEEDED (rc), 1);

/* Query info. */

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

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()), 1);

if (!bstr.isEmpty())

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

CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), 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_USBDeviceNotSupported:

pszState = "Not supported"; break;

case USBDeviceState_USBDeviceUnavailable:

pszState = "Unavailable"; break;

case USBDeviceState_USBDeviceBusy:

pszState = "Busy"; break;

case USBDeviceState_USBDeviceAvailable:

pszState = "Available"; break;

case USBDeviceState_USBDeviceHeld:

pszState = "Held"; break;

case USBDeviceState_USBDeviceCaptured:

pszState = "Captured"; break;

default:

ASSERT (false);

break;

}

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

rc = EnumPtr->HasMore (&fMore);

ASSERT_RET (SUCCEEDED (rc), rc);

}

}

else

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

{

RTPrintf("Global USB Device Filters:\n\n");

ComPtr <IHost> host;

CHECK_ERROR_RET (virtualBox, COMGETTER(Host) (host.asOutParam()), 1);

ComPtr<IHostUSBDeviceFilterCollection> coll;

CHECK_ERROR_RET (host, COMGETTER (USBDeviceFilters)(coll.asOutParam()), 1);

ComPtr<IHostUSBDeviceFilterEnumerator> en;

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

ULONG index = 0;

BOOL more = FALSE;

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), 1);

if (!more)

{

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

}

else

while (more)

{

ComPtr<IHostUSBDeviceFilter> flt;

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

ASSERT_RET (SUCCEEDED (rc), 1);

/* Query info. */

RTPrintf("Index: %lu\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_USBDeviceFilterIgnore:

pszAction = "Ignore";

break;

case USBDeviceFilterAction_USBDeviceFilterHold:

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

rc = en->HasMore (&more);

ASSERT_RET (SUCCEEDED (rc), 1);

index ++;

}

}

else if (strcmp(argv[0], "systemproperties") == 0)

{

ComPtr<ISystemProperties> systemProperties;

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

Bstr str;

ULONG ulValue;

ULONG64 ul64Value;

BOOL flag;

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(MaxGuestVRAM)(&ulValue);

RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue);

systemProperties->COMGETTER(MaxVDISize)(&ul64Value);

RTPrintf("Maximum VDI size: %lu Megabytes\n", ul64Value);

systemProperties->COMGETTER(DefaultVDIFolder)(str.asOutParam());

RTPrintf("Default VDI filder: %lS\n", str.raw());

systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());

RTPrintf("Default machine folder: %lS\n", str.raw());

systemProperties->COMGETTER(RemoteDisplayAuthLibrary)(str.asOutParam());

RTPrintf("VRDP authentication library: %lS\n", str.raw());

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

RTPrintf("Hardware virt. extensions: %s\n", flag ? "yes" : "no");

}

else

{

return errorSyntax(USAGE_LIST, "Invalid parameter '%s'", Utf8Str(argv[0]).raw());

}

return SUCCEEDED(rc) ? 0 : 1;

}

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

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

{

HRESULT rc;

if (argc != 1)

{

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

}

ComPtr<IMachine> machine;

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

if (SUCCEEDED(rc))

{

ASSERT(machine);

CHECK_ERROR(virtualBox, RegisterMachine(machine));

}

return SUCCEEDED(rc) ? 0 : 1;

}

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

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

{

HRESULT rc;

if ((argc != 1) && (argc != 2))

{

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

}

ComPtr<IMachine> machine;

/* assume it's a UUID */

rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());

if (FAILED(rc) || !machine)

{

/* must be a name */

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

}

if (machine)

{

Guid uuid;

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

machine = NULL;

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

if (SUCCEEDED(rc) && machine)

{

/* are we supposed to delete the config file? */

if ((argc == 2) && (strcmp(argv[1], "-delete") == 0))

{

CHECK_ERROR(machine, DeleteSettings());

}

}

}

return SUCCEEDED(rc) ? 0 : 1;

}

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

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

{

HRESULT rc;

Bstr filename;

uint64_t sizeMB = 0;

bool fStatic = false;

Bstr comment;

bool fRegister = false;

const char *type = "normal";

/* 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], "-size") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

sizeMB = RTStrToUInt64(argv[i]);

}

else if (strcmp(argv[i], "-static") == 0)

{

fStatic = true;

}

else if (strcmp(argv[i], "-comment") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

comment = argv[i];

}

else if (strcmp(argv[i], "-register") == 0)

{

fRegister = true;

}

else if (strcmp(argv[i], "-type") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

type = argv[i];

}

else

{

return errorSyntax(USAGE_CREATEVDI, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());

}

}

/* check the outcome */

if (!filename || (sizeMB == 0))

{

return errorSyntax(USAGE_CREATEVDI, "Parameters -filename and -size are required");

}

if (strcmp(type, "normal") && strcmp(type, "writethrough"))

{

return errorArgument("Invalid VDI type '%s' specified", Utf8Str(type).raw());

}

ComPtr<IHardDisk> hardDisk;

CHECK_ERROR(virtualBox, CreateHardDisk(HardDiskStorageType_VirtualDiskImage, hardDisk.asOutParam()));

if (SUCCEEDED(rc) && hardDisk)

{

CHECK_ERROR(hardDisk,COMSETTER(Description)(comment));

ComPtr<IVirtualDiskImage> vdi = hardDisk;

CHECK_ERROR(vdi, COMSETTER(FilePath)(filename));

ComPtr<IProgress> progress;

if (fStatic)

{

CHECK_ERROR(vdi, CreateFixedImage(sizeMB, progress.asOutParam()));

}

else

{

CHECK_ERROR(vdi, CreateDynamicImage(sizeMB, progress.asOutParam()));

}

if (SUCCEEDED(rc) && progress)

{

CHECK_ERROR(progress, WaitForCompletion(-1));

if (SUCCEEDED(rc))

{

progress->COMGETTER(ResultCode)(&rc);

if (FAILED(rc))

{

com::ProgressErrorInfo info(progress);

if (info.isBasicAvailable())

{

RTPrintf("Error: failed to create disk image. Error message: %lS\n", info.getText().raw());

}

else

{

RTPrintf("Error: failed to create disk image. No error message available!\n");

}

}

else

{

Guid uuid;

CHECK_ERROR(hardDisk, COMGETTER(Id)(uuid.asOutParam()));

if (strcmp(type, "normal") == 0)

{

/* nothing required, default */

}

else if (strcmp(type, "writethrough") == 0)

{

CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_WritethroughHardDisk));

}

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

}

}

}

if (SUCCEEDED(rc) && fRegister)

{

CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));

}

}

return SUCCEEDED(rc) ? 0 : 1;

}

static DECLCALLBACK(int) vdiProgressCallback(PVM pVM, unsigned uPercent, void *pvUser)

{

unsigned *pPercent = (unsigned *)pvUser;

if (*pPercent != uPercent)

{

*pPercent = uPercent;

RTPrintf(".");

if ((uPercent % 10) == 0 && uPercent)

RTPrintf("%d%%", uPercent);

RTStrmFlush(g_pStdOut);

}

return VINF_SUCCESS;

}

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

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

{

HRESULT rc;

/* The uuid/filename and a command */

if (argc < 2)

{

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

}

ComPtr<IHardDisk> hardDisk;

ComPtr<IVirtualDiskImage> vdi;

Bstr filepath;

/* first guess is that it's a UUID */

Guid uuid(argv[0]);

rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());

/* no? then it must be a filename */

if (!hardDisk)

{

filepath = argv[0];

CHECK_ERROR(virtualBox, FindVirtualDiskImage(filepath, vdi.asOutParam()));

hardDisk = vdi;

}

else

{

vdi = hardDisk;

}

/* let's find out which command */

if (0)

{

/* hard disk must be registered */

if (SUCCEEDED(rc) && hardDisk && vdi)

{

char *type = NULL;

if (argc <= 2)

{

return errorArgument("Missing argument to for settype");

}

type = argv[2];

HardDiskType_T hddType;

CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));

if (strcmp(type, "normal") == 0)

{

if (hddType != HardDiskType_NormalHardDisk)

CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_NormalHardDisk));

}

else if (strcmp(type, "writethrough") == 0)

{

if (hddType != HardDiskType_WritethroughHardDisk)

CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_WritethroughHardDisk));

}

else if (strcmp(type, "immutable") == 0)

{

if (hddType != HardDiskType_ImmutableHardDisk)

CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_ImmutableHardDisk));

}

else

{

return errorArgument("Invalid VDI type '%s' specified", Utf8Str(type).raw());

}

}

else

{

return errorArgument("Hard disk image not registered");

}

}

else if (strcmp(argv[1], "compact") == 0)

{

ComPtr<IVirtualDiskImage> vdi;

/* the hard disk image might not be registered */

if (!hardDisk)

{

virtualBox->OpenVirtualDiskImage(Bstr(argv[0]), vdi.asOutParam());

if (!vdi)

{

return errorArgument("Hard disk image not found");

}

}

else

vdi = hardDisk;

if (!vdi)

return errorArgument("Invalid hard disk type. The command only works on VDI files\n");

Bstr fileName;

vdi->COMGETTER(FilePath)(fileName.asOutParam());

/* close the file */

hardDisk = NULL;

vdi = NULL;

unsigned uProcent;

RTPrintf("Shrinking '%lS': 0%%", fileName.raw());

int vrc = VDIShrinkImage(Utf8Str(fileName).raw(), vdiProgressCallback, &uProcent);

if (VBOX_FAILURE(vrc))

{

RTPrintf("Error while shrinking hard disk image: %Vrc\n", vrc);

rc = E_FAIL;

}

}

else

{

return errorSyntax(USAGE_MODIFYVDI, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());

}

return SUCCEEDED(rc) ? 0 : 1;

}

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

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

{

HRESULT rc;

/* source VDI and target path */

if (argc != 2)

{

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

}

/* first guess is that it's a UUID */

Guid uuid(argv[0]);

ComPtr<IHardDisk> hardDisk;

rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());

if (!hardDisk)

{

/* not successful? Then it must be a filename */

ComPtr<IVirtualDiskImage> vdi;

CHECK_ERROR(virtualBox, OpenVirtualDiskImage(Bstr(argv[0]), vdi.asOutParam()));

hardDisk = vdi;

}

if (hardDisk)

{

ComPtr<IVirtualDiskImage> vdiOut;

ComPtr<IProgress> progress;

CHECK_ERROR(hardDisk, CloneToImage(Bstr(argv[1]), vdiOut.asOutParam(), progress.asOutParam()));

if (SUCCEEDED(rc))

{

showProgress(progress);

progress->COMGETTER(ResultCode)(&rc);

if (FAILED(rc))

{

com::ProgressErrorInfo info(progress);

if (info.isBasicAvailable())

{

RTPrintf("Error: failed to clone disk image. Error message: %lS\n", info.getText().raw());

}

else

{

RTPrintf("Error: failed to clone disk image. No error message available!\n");

}

}

}

}

return SUCCEEDED(rc) ? 0 : 1;

}

static int handleConvertDDImage(int argc, char *argv[])

{

#ifdef __LINUX__

const bool fReadFromStdIn = !strcmp(argv[0], "stdin");

#else

const bool fReadFromStdIn = false;

#endif

if ((!fReadFromStdIn && argc != 2) || (fReadFromStdIn && argc != 3))

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

RTPrintf("Converting VDI: from DD image file=\"%s\" to file=\"%s\"...\n",

argv[0], argv[1]);

/* open raw image file. */

RTFILE File;

int rc = VINF_SUCCESS;

if (fReadFromStdIn)

File = 0;

else

rc = RTFileOpen(&File, argv[0], RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);

if (VBOX_FAILURE(rc))

{

RTPrintf("File=\"%s\" open error: %Rrf\n", argv[0], rc);

return rc;

}

uint64_t cbFile;

/* get image size. */

if (fReadFromStdIn)

cbFile = RTStrToUInt64(argv[2]);

else

rc = RTFileGetSize(File, &cbFile);

if (VBOX_SUCCESS(rc))

{

RTPrintf("Creating fixed image with size %RU64Bytes (%RU64MB)...\n", cbFile, (cbFile + _1M - 1) / _1M);

char pszComment[256];

RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", argv[0]);

rc = VDICreateBaseImage(argv[1],

VDI_IMAGE_TYPE_FIXED,

cbFile,

pszComment, NULL, NULL);

if (VBOX_SUCCESS(rc))

{

PVDIDISK pVdi = VDIDiskCreate();

rc = VDIDiskOpenImage(pVdi, argv[1], VDI_OPEN_FLAGS_NORMAL);

if (VBOX_SUCCESS(rc))

{

/* alloc work buffer. */

void *pvBuf = RTMemAlloc(VDIDiskGetBufferSize(pVdi));

if (pvBuf)

{

uint64_t off = 0;

while (off < cbFile)

{

unsigned cbRead = 0;

rc = RTFileRead(File, pvBuf, VDIDiskGetBufferSize(pVdi), &cbRead);

if (VBOX_FAILURE(rc) || !cbRead)

break;

rc = VDIDiskWrite(pVdi, off, pvBuf, cbRead);

if (VBOX_FAILURE(rc))

break;

off += cbRead;

}

RTMemFree(pvBuf);

}

else

rc = VERR_NO_MEMORY;

VDIDiskCloseImage(pVdi);

}

if (VBOX_FAILURE(rc))

{

/* delete image on error */

RTPrintf("Failed (%Vrc)!\n", rc);

VDIDeleteImage(argv[1]);

}

}

else

RTPrintf("Failed to create output file (%Vrc)!\n", rc);

}

RTFileClose(File);

return rc;

}

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

ComPtr <IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)

{

HRESULT rc;

Bstr server;

Bstr target;

uint16_t port = UINT16_MAX;

uint64_t lun = UINT64_MAX;

Bstr username;

Bstr password;

Bstr comment;

/* at least server and target */

if (argc < 4)

{

return errorSyntax(USAGE_ADDISCSIDISK, "Not enough parameters");

}

/* let's have a closer look at the arguments */

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

{

if (strcmp(argv[i], "-server") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

server = argv[i];

}

else if (strcmp(argv[i], "-target") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

target = argv[i];

}

else if (strcmp(argv[i], "-port") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

port = atoi(argv[i]);

}

else if (strcmp(argv[i], "-lun") == 0)

{

/** @todo move the LUN encoding algorithm into IISCSIHardDisk, add decoding */

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

char *pszNext;

int rc = RTStrToUInt64Ex(argv[i], &pszNext, 0, &lun);

if (VBOX_FAILURE(rc) || *pszNext != '\0' || lun >= 16384)

return errorArgument("Invalid LUN number '%s'", argv[i]);

if (lun <= 255)

{

/* Assume bus identifier = 0. */

lun = (lun << 48); /* uses peripheral device addressing method */

}

else

{

/* Check above already limited the LUN to 14 bits. */

lun = (lun << 48) | RT_BIT_64(62); /* uses flat space addressing method */

}

}

else if (strcmp(argv[i], "-encodedlun") == 0)

{

if (argc <= i + 1)

{

return errorArgument("Missing argument to '%s'", argv[i]);

}

i++;

char *pszNext;

int rc = RTStrToUInt64Ex(argv[i], &pszNext, 0, &lun);

if (VBOX_FAILURE(rc) || *pszNext != '\0')

return errorArgument("Invalid encoded LUN number '%s'", argv[i]);

}

else if (strcmp(argv[i], "-username") == 0)

{