VBoxManageInfo.cpp revision 8c58249d7f93d82395aa6c8b31526443892bc375
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync/* $Id$ */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync/** @file
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * VBoxManage - The 'showvminfo' command and helper routines.
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync/*
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * Copyright (C) 2006-2010 Oracle Corporation
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync *
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * available from http://www.virtualbox.org. This file is free software;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * you can redistribute it and/or modify it under the terms of the GNU
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * General Public License (GPL) as published by the Free Software
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#ifndef VBOX_ONLY_DOCS
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync/*******************************************************************************
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync* Header Files *
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync*******************************************************************************/
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/com/com.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/com/string.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/com/Guid.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/com/array.h>
9d0256d0854254b2717550a64a6e5871a1123a0dvboxsync#include <VBox/com/ErrorInfo.h>
35396ee506ef68dd1c161f1ef2c3c0b68a146ff2vboxsync#include <VBox/com/errorprint.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/com/VirtualBox.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <VBox/log.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <iprt/stream.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <iprt/time.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <iprt/string.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <iprt/getopt.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include <iprt/ctype.h>
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#include "VBoxManage.h"
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsyncusing namespace com;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync// funcs
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync///////////////////////////////////////////////////////////////////////////////
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsyncvoid showSnapshots(ComPtr<ISnapshot> &rootSnapshot,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<ISnapshot> &currentSnapshot,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync VMINFO_DETAILS details,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync const Bstr &prefix /* = ""*/,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync int level /*= 0*/)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync{
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /* start with the root */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr name;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr uuid;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rootSnapshot->COMGETTER(Name)(name.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rootSnapshot->COMGETTER(Id)(uuid.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /* print with hierarchical numbering */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("SnapshotName%lS=\"%lS\"\n", prefix.raw(), name.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("SnapshotUUID%lS=\"%s\"\n", prefix.raw(), Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /* print with indentation */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync bool fCurrent = (rootSnapshot == currentSnapshot);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf(" %lSName: %lS (UUID: %s)%s\n",
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync prefix.raw(),
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync name.raw(),
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync Utf8Str(uuid).raw(),
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync (fCurrent) ? " *" : "");
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync }
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync /* get the children */
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync SafeIfaceArray <ISnapshot> coll;
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync rootSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(coll));
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (!coll.isNull())
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync for (size_t index = 0; index < coll.size(); ++index)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<ISnapshot> snapshot = coll[index];
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (snapshot)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr newPrefix;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync newPrefix = Utf8StrFmt("%lS-%d", prefix.raw(), index + 1);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync newPrefix = Utf8StrFmt("%lS ", prefix.raw());
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync }
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync /* recursive call */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync showSnapshots(snapshot, currentSnapshot, details, newPrefix, level + 1);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync}
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsyncstatic void makeTimeStr (char *s, int cb, int64_t millies)
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync{
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTTIME t;
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTTIMESPEC ts;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTTimeSpecSetMilli(&ts, millies);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTTimeExplode (&t, &ts);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync t.i32Year, t.u8Month, t.u8MonthDay,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync t.u8Hour, t.u8Minute, t.u8Second);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync}
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync/* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync time. MSC 7.1/32 doesn't have quite as much trouble with it, but still
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync sufficient to qualify for this hack as well since this code isn't performance
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync critical and probably won't gain much from the extra optimizing in real life. */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#if defined(_MSC_VER)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync# pragma optimize("g", off)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync#endif
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsyncHRESULT showVMInfo (ComPtr<IVirtualBox> virtualBox,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<IMachine> machine,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync VMINFO_DETAILS details /*= VMINFO_NONE*/,
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<IConsole> console /*= ComPtr <IConsole> ()*/)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync{
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync HRESULT rc;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /*
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * The rules for output in -argdump format:
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * 1) the key part (the [0-9a-zA-Z_]+ string before the '=' delimiter)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * is all lowercase for "VBoxManage modifyvm" parameters. Any
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * other values printed are in CamelCase.
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * 2) strings (anything non-decimal) are printed surrounded by
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * double quotes '"'. If the strings themselves contain double
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * quotes, these characters are escaped by '\'. Any '\' character
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * in the original string is also escaped by '\'.
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync * 3) numbers (containing just [0-9\-]) are written out unchanged.
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /** @todo the quoting is not yet implemented! */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync /** @todo error checking! */
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync BOOL accessible = FALSE;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync CHECK_ERROR(machine, COMGETTER(Accessible)(&accessible));
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (FAILED(rc)) return rc;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr uuid;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(Id)(uuid.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (!accessible)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_COMPACT)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("\"<inaccessible>\" {%s}\n", Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("name=\"<inaccessible>\"\n");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Name: <inaccessible!>\n");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("UUID: %s\n", Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details != VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr settingsFilePath;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Config file: %lS\n", settingsFilePath.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<IVirtualBoxErrorInfo> accessError;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(AccessError)(accessError.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Access error details:\n");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ErrorInfo ei(accessError);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync GluePrintErrorInfo(ei);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("\n");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync return S_OK;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr machineName;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(Name)(machineName.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_COMPACT)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("\"%lS\" {%s}\n", machineName.raw(), Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync return S_OK;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("name=\"%lS\"\n", machineName.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Name: %lS\n", machineName.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr osTypeId;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<IGuestOSType> osType;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr osName;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = osType->COMGETTER(Description)(osName.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("ostype=\"%lS\"\n", osTypeId.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Guest OS: %lS\n", osName.raw());
f65e6cba3e74ffd3dc9e6053828dcc82b367e8devboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("UUID: %s\n", Utf8Str(uuid).raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr settingsFilePath;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("CfgFile=\"%lS\"\n", settingsFilePath.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Config file: %lS\n", settingsFilePath.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync Bstr strHardwareUuid;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(HardwareUUID)(strHardwareUuid.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("hardwareuuid=\"%lS\"\n", strHardwareUuid.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
36c5021c9ff03eb19d9818903cea95d2e43bd6bcvboxsync RTPrintf("Hardware UUID: %lS\n", strHardwareUuid.raw());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ULONG memorySize;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(MemorySize)(&memorySize);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("memory=%u\n", memorySize);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Memory size: %uMB\n", memorySize);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ULONG vramSize;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->COMGETTER(VRAMSize)(&vramSize);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("vram=%u\n", vramSize);
35396ee506ef68dd1c161f1ef2c3c0b68a146ff2vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("VRAM size: %uMB\n", vramSize);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync BOOL fHpetEnabled;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync machine->COMGETTER(HpetEnabled)(&fHpetEnabled);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("hpet=\"%s\"\n", fHpetEnabled ? "on" : "off");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTPrintf("HPET: %s\n", fHpetEnabled ? "on" : "off");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync ULONG numCpus;
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync rc = machine->COMGETTER(CPUCount)(&numCpus);
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync if (details == VMINFO_MACHINEREADABLE)
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTPrintf("cpus=%u\n", numCpus);
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync else
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync RTPrintf("Number of CPUs: %u\n", numCpus);
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync
3b884f2d817ce2af98e0c2c3fed82ade29e991b8vboxsync BOOL fSyntheticCpu;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync machine->GetCPUProperty(CPUPropertyType_Synthetic, &fSyntheticCpu);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
36c5021c9ff03eb19d9818903cea95d2e43bd6bcvboxsync RTPrintf("synthcpu=\"%s\"\n", fSyntheticCpu ? "on" : "off");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Synthetic Cpu: %s\n", fSyntheticCpu ? "on" : "off");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details != VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("CPUID overrides: ");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ULONG cFound = 0;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync static uint32_t const s_auCpuIdRanges[] =
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync UINT32_C(0x00000000), UINT32_C(0x0000000a),
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync UINT32_C(0x80000000), UINT32_C(0x8000000a)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync };
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ULONG uEAX, uEBX, uECX, uEDX;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync rc = machine->GetCPUIDLeaf(uLeaf, &uEAX, &uEBX, &uECX, &uEDX);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (SUCCEEDED(rc))
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x", uLeaf, uEAX, uEBX, uECX, uEDX);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (!cFound)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Leaf no. EAX EBX ECX EDX\n");
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync RTPrintf(" %08x %08x %08x %08x %08x\n", uLeaf, uEAX, uEBX, uECX, uEDX);
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync }
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync cFound++;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (!cFound && details != VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("None\n");
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr <IBIOSSettings> biosSettings;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync BIOSBootMenuMode_T bootMenuMode;
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync const char *pszBootMenu = NULL;
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync switch (bootMenuMode)
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync case BIOSBootMenuMode_Disabled:
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync pszBootMenu = "disabled";
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync break;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync case BIOSBootMenuMode_MenuOnly:
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync pszBootMenu = "menuonly";
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync pszBootMenu = "menu only";
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync break;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync default:
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync pszBootMenu = "messageandmenu";
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync pszBootMenu = "message and menu";
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot menu mode: %s\n", pszBootMenu);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync ULONG maxBootPosition = 0;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync ComPtr<ISystemProperties> systemProperties;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync systemProperties->COMGETTER(MaxBootPosition)(&maxBootPosition);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync for (ULONG i = 1; i <= maxBootPosition; i++)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync DeviceType_T bootOrder;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync machine->GetBootOrder(i, &bootOrder);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (bootOrder == DeviceType_Floppy)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"floppy\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync RTPrintf("Boot Device (%d): Floppy\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else if (bootOrder == DeviceType_DVD)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"dvd\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot Device (%d): DVD\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync else if (bootOrder == DeviceType_HardDisk)
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync RTPrintf("boot%d=\"disk\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot Device (%d): HardDisk\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else if (bootOrder == DeviceType_Network)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"net\"\n", i);
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync else
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync RTPrintf("Boot Device (%d): Network\n", i);
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else if (bootOrder == DeviceType_USB)
1222ff94540f6426532c1f1714f0717fdcf92e46vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"usb\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot Device (%d): USB\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else if (bootOrder == DeviceType_SharedFolder)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"sharedfolder\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot Device (%d): Shared Folder\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync {
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("boot%d=\"none\"\n", i);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync else
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("Boot Device (%d): Not Assigned\n", i);
35396ee506ef68dd1c161f1ef2c3c0b68a146ff2vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync }
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync BOOL acpiEnabled;
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync biosSettings->COMGETTER(ACPIEnabled)(&acpiEnabled);
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync if (details == VMINFO_MACHINEREADABLE)
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync RTPrintf("acpi=\"%s\"\n", acpiEnabled ? "on" : "off");
7a61a5714b9a39ac3bd59e52b0843ef498350a35vboxsync 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->GetCPUProperty(CPUPropertyType_PAE, &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);
BOOL RTCUseUTC;
machine->COMGETTER(RTCUseUTC)(&RTCUseUTC);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("rtcuseutc=\"%s\"\n", RTCUseUTC ? "on" : "off");
else
RTPrintf("RTC: %s\n", RTCUseUTC ? "UTC" : "local time");
BOOL hwVirtExEnabled;
machine->GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &hwVirtExEnabled);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("hwvirtex=\"%s\"\n", hwVirtExEnabled ? "on" : "off");
else
RTPrintf("Hardw. virt.ext: %s\n", hwVirtExEnabled ? "on" : "off");
BOOL hwVirtExExclusive;
machine->GetHWVirtExProperty(HWVirtExPropertyType_Exclusive, &hwVirtExExclusive);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("hwvirtexexcl=\"%s\"\n", hwVirtExExclusive ? "on" : "off");
else
RTPrintf("Hardw. virt.ext exclusive: %s\n", hwVirtExExclusive ? "on" : "off");
BOOL HWVirtExNestedPagingEnabled;
machine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &HWVirtExNestedPagingEnabled);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("nestedpaging=\"%s\"\n", HWVirtExNestedPagingEnabled ? "on" : "off");
else
RTPrintf("Nested Paging: %s\n", HWVirtExNestedPagingEnabled ? "on" : "off");
BOOL HWVirtExLargePagesEnabled;
machine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &HWVirtExLargePagesEnabled);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("largepages=\"%s\"\n", HWVirtExLargePagesEnabled ? "on" : "off");
else
RTPrintf("Large Pages: %s\n", HWVirtExLargePagesEnabled ? "on" : "off");
BOOL HWVirtExVPIDEnabled;
machine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &HWVirtExVPIDEnabled);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("vtxvpid=\"%s\"\n", HWVirtExVPIDEnabled ? "on" : "off");
else
RTPrintf("VT-x VPID: %s\n", HWVirtExVPIDEnabled ? "on" : "off");
MachineState_T machineState;
const char *pszState = NULL;
rc = machine->COMGETTER(State)(&machineState);
switch (machineState)
{
case MachineState_PoweredOff:
pszState = details == VMINFO_MACHINEREADABLE ? "poweroff" : "powered off";
break;
case MachineState_Saved:
pszState = "saved";
break;
case MachineState_Aborted:
pszState = "aborted";
break;
case MachineState_Teleported:
pszState = "teleported";
break;
case MachineState_Running:
pszState = "running";
break;
case MachineState_Paused:
pszState = "paused";
break;
case MachineState_Stuck:
pszState = details == VMINFO_MACHINEREADABLE ? "gurumeditation" : "guru meditation";
break;
case MachineState_LiveSnapshotting:
pszState = details == VMINFO_MACHINEREADABLE ? "livesnapshotting" : "live snapshotting";
break;
case MachineState_Teleporting:
pszState = "teleporting";
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;
case MachineState_TeleportingPausedVM:
pszState = details == VMINFO_MACHINEREADABLE ? "teleportingpausedvm" : "teleporting paused vm";
break;
case MachineState_TeleportingIn:
pszState = details == VMINFO_MACHINEREADABLE ? "teleportingin" : "teleporting (incoming)";
break;
case MachineState_RestoringSnapshot:
pszState = details == VMINFO_MACHINEREADABLE ? "restoringsnapshot" : "restoring snapshot";
break;
case MachineState_DeletingSnapshot:
pszState = details == VMINFO_MACHINEREADABLE ? "deletingsnapshot" : "deleting snapshot";
break;
case MachineState_DeletingSnapshotOnline:
pszState = details == VMINFO_MACHINEREADABLE ? "deletingsnapshotlive" : "deleting snapshot live";
break;
case MachineState_DeletingSnapshotPaused:
pszState = details == VMINFO_MACHINEREADABLE ? "deletingsnapshotlivepaused" : "deleting snapshot live paused";
break;
case MachineState_SettingUp:
pszState = details == VMINFO_MACHINEREADABLE ? "settingup" : "setting up";
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));
Bstr stateFile;
machine->COMGETTER(StateFilePath)(stateFile.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("VMState=\"%s\"\n", pszState);
RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime);
if (!stateFile.isEmpty())
RTPrintf("VMStateFile=\"%lS\"\n", stateFile.raw());
}
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);
BOOL accelerate3d;
machine->COMGETTER(Accelerate3DEnabled)(&accelerate3d);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("accelerate3d=\"%s\"\n", accelerate3d ? "on" : "off");
else
RTPrintf("3D Acceleration: %s\n", accelerate3d ? "on" : "off");
#ifdef VBOX_WITH_VIDEOHWACCEL
BOOL accelerate2dVideo;
machine->COMGETTER(Accelerate2DVideoEnabled)(&accelerate2dVideo);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("accelerate2dvideo=\"%s\"\n", accelerate2dVideo ? "on" : "off");
else
RTPrintf("2D Video Acceleration: %s\n", accelerate2dVideo ? "on" : "off");
#endif
BOOL teleporterEnabled;
machine->COMGETTER(TeleporterEnabled)(&teleporterEnabled);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("teleporterenabled=\"%s\"\n", teleporterEnabled ? "on" : "off");
else
RTPrintf("Teleporter Enabled: %s\n", teleporterEnabled ? "on" : "off");
ULONG teleporterPort;
machine->COMGETTER(TeleporterPort)(&teleporterPort);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("teleporterport=%u\n", teleporterPort);
else
RTPrintf("Teleporter Port: %u\n", teleporterPort);
Bstr teleporterAddress;
machine->COMGETTER(TeleporterAddress)(teleporterAddress.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("teleporteraddress=\"%lS\"\n", teleporterAddress.raw());
else
RTPrintf("Teleporter Address: %lS\n", teleporterAddress.raw());
Bstr teleporterPassword;
machine->COMGETTER(TeleporterPassword)(teleporterPassword.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("teleporterpassword=\"%lS\"\n", teleporterPassword.raw());
else
RTPrintf("Teleporter Password: %lS\n", teleporterPassword.raw());
/*
* Storage Controllers and their attached Mediums.
*/
com::SafeIfaceArray<IStorageController> storageCtls;
CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam (storageCtls)));
for (size_t i = 0; i < storageCtls.size(); ++ i)
{
ComPtr<IStorageController> storageCtl = storageCtls[i];
StorageControllerType_T enmCtlType = StorageControllerType_Null;
const char *pszCtl = NULL;
ULONG ulValue = 0;
Bstr storageCtlName;
storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("storagecontrollername%u=\"%lS\"\n", i, storageCtlName.raw());
else
RTPrintf("Storage Controller Name (%u): %lS\n", i, storageCtlName.raw());
storageCtl->COMGETTER(ControllerType)(&enmCtlType);
switch (enmCtlType)
{
case StorageControllerType_LsiLogic:
pszCtl = "LsiLogic";
break;
case StorageControllerType_BusLogic:
pszCtl = "BusLogic";
break;
case StorageControllerType_IntelAhci:
pszCtl = "IntelAhci";
break;
case StorageControllerType_PIIX3:
pszCtl = "PIIX3";
break;
case StorageControllerType_PIIX4:
pszCtl = "PIIX4";
break;
case StorageControllerType_ICH6:
pszCtl = "ICH6";
break;
case StorageControllerType_I82078:
pszCtl = "I82078";
break;
default:
pszCtl = "unknown";
}
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("storagecontrollertype%u=\"%s\"\n", i, pszCtl);
else
RTPrintf("Storage Controller Type (%u): %s\n", i, pszCtl);
storageCtl->COMGETTER(Instance)(&ulValue);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("storagecontrollerinstance%u=\"%lu\"\n", i, ulValue);
else
RTPrintf("Storage Controller Instance Number (%u): %lu\n", i, ulValue);
storageCtl->COMGETTER(MaxPortCount)(&ulValue);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("storagecontrollermaxportcount%u=\"%lu\"\n", i, ulValue);
else
RTPrintf("Storage Controller Max Port Count (%u): %lu\n", i, ulValue);
storageCtl->COMGETTER(PortCount)(&ulValue);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("storagecontrollerportcount%u=\"%lu\"\n", i, ulValue);
else
RTPrintf("Storage Controller Port Count (%u): %lu\n", i, ulValue);
}
for (size_t j = 0; j < storageCtls.size(); ++ j)
{
ComPtr<IStorageController> storageCtl = storageCtls[j];
ComPtr<IMedium> medium;
Bstr storageCtlName;
Bstr filePath;
ULONG cDevices;
ULONG cPorts;
storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
storageCtl->COMGETTER(MaxDevicesPerPortCount)(&cDevices);
storageCtl->COMGETTER(PortCount)(&cPorts);
for (ULONG i = 0; i < cPorts; ++ i)
{
for (ULONG k = 0; k < cDevices; ++ k)
{
rc = machine->GetMedium(storageCtlName, i, k, medium.asOutParam());
if (SUCCEEDED(rc) && medium)
{
BOOL fPassthrough;
ComPtr<IMediumAttachment> mediumAttach;
rc = machine->GetMediumAttachment(storageCtlName, i, k, mediumAttach.asOutParam());
if (SUCCEEDED(rc) && mediumAttach)
mediumAttach->COMGETTER(Passthrough)(&fPassthrough);
medium->COMGETTER(Location)(filePath.asOutParam());
medium->COMGETTER(Id)(uuid.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("\"%lS-%d-%d\"=\"%lS\"\n", storageCtlName.raw(),
i, k, filePath.raw());
RTPrintf("\"%lS-ImageUUID-%d-%d\"=\"%s\"\n",
storageCtlName.raw(), i, k, Utf8Str(uuid).raw());
if (fPassthrough)
RTPrintf("\"%lS-dvdpassthrough\"=\"%s\"\n", storageCtlName.raw(),
fPassthrough ? "on" : "off");
}
else
{
RTPrintf("%lS (%d, %d): %lS (UUID: %s)",
storageCtlName.raw(), i, k, filePath.raw(),
Utf8Str(uuid).raw());
if (fPassthrough)
RTPrintf(" (passthrough enabled)");
RTPrintf("\n");
}
}
else if (SUCCEEDED(rc))
{
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("\"%lS-%d-%d\"=\"emptydrive\"\n", storageCtlName.raw(), i, k);
else
RTPrintf("%lS (%d, %d): Empty\n", storageCtlName.raw(), i, k);
}
else
{
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("\"%lS-%d-%d\"=\"none\"\n", storageCtlName.raw(), i, k);
}
}
}
}
/* 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;
Utf8Str strNatSettings = "";
Utf8Str strNatForwardings = "";
NetworkAttachmentType_T attachment;
nic->COMGETTER(AttachmentType)(&attachment);
switch (attachment)
{
case NetworkAttachmentType_Null:
if (details == VMINFO_MACHINEREADABLE)
strAttachment = "null";
else
strAttachment = "none";
break;
case NetworkAttachmentType_NAT:
{
Bstr strNetwork;
ComPtr<INATEngine> driver;
nic->COMGETTER(NatDriver)(driver.asOutParam());
driver->COMGETTER(Network)(strNetwork.asOutParam());
com::SafeArray<BSTR> forwardings;
driver->COMGETTER(Redirects)(ComSafeArrayAsOutParam(forwardings));
strNatForwardings = "";
for (size_t i = 0; i < forwardings.size(); ++i)
{
bool fSkip = false;
uint16_t port = 0;
BSTR r = forwardings[i];
Utf8Str utf = Utf8Str(r);
Utf8Str strName;
Utf8Str strProto;
Utf8Str strHostPort;
Utf8Str strHostIP;
Utf8Str strGuestPort;
Utf8Str strGuestIP;
size_t pos, ppos;
pos = ppos = 0;
#define ITERATE_TO_NEXT_TERM(res, str, pos, ppos) \
do { \
pos = str.find(",", ppos); \
if (pos == Utf8Str::npos) \
{ \
Log(( #res " extracting from %s is failed\n", str.raw())); \
fSkip = true; \
} \
res = str.substr(ppos, pos - ppos); \
Log2((#res " %s pos:%d, ppos:%d\n", res.raw(), pos, ppos)); \
ppos = pos + 1; \
} while (0)
ITERATE_TO_NEXT_TERM(strName, utf, pos, ppos);
if (fSkip) continue;
ITERATE_TO_NEXT_TERM(strProto, utf, pos, ppos);
if (fSkip) continue;
ITERATE_TO_NEXT_TERM(strHostIP, utf, pos, ppos);
if (fSkip) continue;
ITERATE_TO_NEXT_TERM(strHostPort, utf, pos, ppos);
if (fSkip) continue;
ITERATE_TO_NEXT_TERM(strGuestIP, utf, pos, ppos);
if (fSkip) continue;
strGuestPort = utf.substr(ppos, utf.length() - ppos);
#undef ITERATE_TO_NEXT_TERM
switch (strProto.toUInt32())
{
case NATProtocol_TCP:
strProto = "tcp";
break;
case NATProtocol_UDP:
strProto = "udp";
break;
default:
strProto = "unk";
break;
}
if (details == VMINFO_MACHINEREADABLE)
{
strNatForwardings = Utf8StrFmt("%sForwarding(%d)=\"%s,%s,%s,%s,%s,%s\"\n",
strNatForwardings.raw(), i, strName.raw(), strProto.raw(),
strHostIP.isEmpty() ? "": strHostIP.raw(), strHostPort.raw(),
strGuestIP.isEmpty() ? "": strGuestIP.raw(), strGuestPort.raw());
}
else
{
strNatForwardings = Utf8StrFmt("%sNIC %d Rule(%d): name = %s, protocol = %s,"
" host ip = %s, host port = %s, guest ip = %s, guest port = %s\n",
strNatForwardings.raw(), currentNIC + 1, i, strName.raw(), strProto.raw(),
strHostIP.isEmpty() ? "": strHostIP.raw(), strHostPort.raw(),
strGuestIP.isEmpty() ? "": strGuestIP.raw(), strGuestPort.raw());
}
}
ULONG mtu = 0;
ULONG sockSnd = 0;
ULONG sockRcv = 0;
ULONG tcpSnd = 0;
ULONG tcpRcv = 0;
driver->GetNetworkSettings(&mtu, &sockSnd, &sockRcv, &tcpSnd, &tcpRcv);
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("natnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.length() ? strNetwork.raw(): Bstr("nat").raw());
strAttachment = "nat";
strNatSettings = Utf8StrFmt("mtu=\"%d\"\nsockSnd=\"%d\"\nsockRcv=\"%d\"\ntcpWndSnd=\"%d\"\ntcpWndRcv=\"%d\"\n",
mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64 , tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64);
}
else
{
strAttachment = "NAT";
strNatSettings = Utf8StrFmt("NIC %d Settings: MTU: %d, Socket( send: %d, receive: %d), TCP Window( send:%d, receive: %d)\n",
currentNIC + 1, mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64 , tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64);
}
break;
}
case NetworkAttachmentType_Bridged:
{
Bstr strBridgeAdp;
nic->COMGETTER(HostInterface)(strBridgeAdp.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("bridgeadapter%d=\"%lS\"\n", currentNIC + 1, strBridgeAdp.raw());
strAttachment = "bridged";
}
else
strAttachment = Utf8StrFmt("Bridged Interface '%lS'", strBridgeAdp.raw());
break;
}
case NetworkAttachmentType_Internal:
{
Bstr strNetwork;
nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("intnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
strAttachment = "intnet";
}
else
strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).raw());
break;
}
#if defined(VBOX_WITH_NETFLT)
case NetworkAttachmentType_HostOnly:
{
Bstr strHostonlyAdp;
nic->COMGETTER(HostInterface)(strHostonlyAdp.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("hostonlyadapter%d=\"%lS\"\n", currentNIC + 1, strHostonlyAdp.raw());
strAttachment = "hostonly";
}
else
strAttachment = Utf8StrFmt("Host-only Interface '%lS'", strHostonlyAdp.raw());
break;
}
#endif
#ifdef VBOX_WITH_VDE
case NetworkAttachmentType_VDE:
{
Bstr strVDEAdp;
nic->COMGETTER(VDENetwork)(strVDEAdp.asOutParam());
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("vdenet%d=\"%lS\"\n", currentNIC + 1, strVDEAdp.raw());
strAttachment = "VDE";
}
else
strAttachment = Utf8StrFmt("VDE Network '%lS'", strVDEAdp.raw());
break;
}
#endif
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;
case NetworkAdapterType_I82545EM:
strNICType = "82545EM";
break;
#endif
#ifdef VBOX_WITH_VIRTIO
case NetworkAdapterType_Virtio:
strNICType = "virtio";
break;
#endif /* VBOX_WITH_VIRTIO */
default:
strNICType = "unknown";
break;
}
/* reported line speed */
ULONG ulLineSpeed;
nic->COMGETTER(LineSpeed)(&ulLineSpeed);
/* boot priority of the adapter */
ULONG ulBootPriority;
nic->COMGETTER(BootPriority)(&ulBootPriority);
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, Boot priority: %d\n",
currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),
fConnected ? "on" : "off",
fTraceEnabled ? "on" : "off",
traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
strNICType.raw(),
ulLineSpeed / 1000,
(int)ulBootPriority);
if (strNatSettings.length())
RTPrintf(strNatSettings.raw());
if (strNatForwardings.length())
RTPrintf(strNatForwardings.raw());
}
}
}
/* Pointing device information */
PointingHidType_T aPointingHid;
const char *pszHid = "Unknown";
const char *pszMrHid = "unknown";
machine->COMGETTER(PointingHidType)(&aPointingHid);
switch (aPointingHid)
{
case PointingHidType_None:
pszHid = "None";
pszMrHid = "none";
break;
case PointingHidType_PS2Mouse:
pszHid = "PS/2 Mouse";
pszMrHid = "ps2mouse";
break;
case PointingHidType_USBMouse:
pszHid = "USB Mouse";
pszMrHid = "usbmouse";
break;
case PointingHidType_USBTablet:
pszHid = "USB Tablet";
pszMrHid = "usbtablet";
break;
case PointingHidType_ComboMouse:
pszHid = "USB Tablet and PS/2 Mouse";
pszMrHid = "combomouse";
break;
default:
break;
}
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("hidpointing=\"%s\"\n", pszMrHid);
else
RTPrintf("Pointing Device: %s\n", pszHid);
/* Keyboard device information */
KeyboardHidType_T aKeyboardHid;
machine->COMGETTER(KeyboardHidType)(&aKeyboardHid);
pszHid = "Unknown";
pszMrHid = "unknown";
switch (aKeyboardHid)
{
case KeyboardHidType_None:
pszHid = "None";
pszMrHid = "none";
break;
case KeyboardHidType_PS2Keyboard:
pszHid = "PS/2 Keyboard";
pszMrHid = "ps2kbd";
break;
case KeyboardHidType_USBKeyboard:
pszHid = "USB Keyboard";
pszMrHid = "usbkbd";
break;
case KeyboardHidType_ComboKeyboard:
pszHid = "USB and PS/2 Keyboard";
pszMrHid = "combokbd";
break;
default:
break;
}
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("hidkeyboard=\"%s\"\n", pszMrHid);
else
RTPrintf("Keyboard Device: %s\n", pszHid);
/* 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_RawFile:
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
path.raw());
else
RTPrintf(", attached to raw file '%lS'\n",
path.raw());
break;
case PortMode_HostPipe:
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("uartmode%d=\"%s,%lS\"\n", currentUART + 1,
fServer ? "server" : "client", path.raw());
else
RTPrintf(", attached to pipe (%s) '%lS'\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",
fEnabled ? "enabled" : "disabled");
if (fEnabled)
RTPrintf(" (Driver: %s, Controller: %s)",
pszDrv, pszCtrl);
RTPrintf("\n");
}
}
/* 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);
do
{
ULONG xRes, yRes, bpp;
rc = display->GetScreenResolution (0, &xRes, &yRes, &bpp);
if (rc == E_ACCESSDENIED)
break; /* VM not powered up */
if (FAILED(rc))
{
com::ErrorInfo info (display);
GluePrintErrorInfo(info);
return 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);
}
while (0);
}
/*
* VRDP
*/
ComPtr<IVRDPServer> vrdpServer;
rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
if (SUCCEEDED(rc) && vrdpServer)
{
BOOL fEnabled = false;
vrdpServer->COMGETTER(Enabled)(&fEnabled);
if (fEnabled)
{
LONG vrdpPort = -1;
Bstr ports;
vrdpServer->COMGETTER(Ports)(ports.asOutParam());
Bstr address;
vrdpServer->COMGETTER(NetAddress)(address.asOutParam());
BOOL fMultiCon;
vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
BOOL fReuseCon;
vrdpServer->COMGETTER(ReuseSingleConnection)(&fReuseCon);
BOOL fVideoChannel;
vrdpServer->COMGETTER(VideoChannel)(&fVideoChannel);
ULONG ulVideoChannelQuality;
vrdpServer->COMGETTER(VideoChannelQuality)(&ulVideoChannelQuality);
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 (console)
{
ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
rc = remoteDisplayInfo->COMGETTER(Port)(&vrdpPort);
if (rc == E_ACCESSDENIED)
{
vrdpPort = -1; /* VM not powered up */
}
if (FAILED(rc))
{
com::ErrorInfo info (remoteDisplayInfo);
GluePrintErrorInfo(info);
return rc;
}
}
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("vrdp=\"on\"\n");
RTPrintf("vrdpport=%d\n", vrdpPort);
RTPrintf("vrdpports=\"%lS\"\n", ports.raw());
RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());
RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);
RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");
RTPrintf("vrdpreusecon=\"%s\"\n", fReuseCon ? "on" : "off");
RTPrintf("vrdpvideochannel=\"%s\"\n", fVideoChannel ? "on" : "off");
if (fVideoChannel)
RTPrintf("vrdpvideochannelquality=\"%d\"\n", ulVideoChannelQuality);
}
else
{
if (address.isEmpty())
address = "0.0.0.0";
RTPrintf("VRDP: enabled (Address %lS, Ports %lS, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n", address.raw(), ports.raw(), fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType);
if (console && vrdpPort != -1 && vrdpPort != 0)
RTPrintf("VRDP port: %d\n", vrdpPort);
if (fVideoChannel)
RTPrintf("Video redirection: enabled (Quality %d)\n", ulVideoChannelQuality);
else
RTPrintf("Video redirection: disabled\n");
}
}
else
{
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("vrdp=\"off\"\n");
else
RTPrintf("VRDP: disabled\n");
}
}
/*
* USB.
*/
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");
SafeIfaceArray <IUSBDeviceFilter> Coll;
rc = USBCtl->COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll));
if (SUCCEEDED(rc))
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\nUSB Device Filters:\n\n");
if (Coll.size() == 0)
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("<none>\n\n");
}
else
{
for (size_t index = 0; index < Coll.size(); ++index)
{
ComPtr<IUSBDeviceFilter> DevPtr = Coll[index];
/* Query info. */
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("Index: %zu\n", index);
BOOL bActive = FALSE;
CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
if (details == VMINFO_MACHINEREADABLE)
RTPrintf("USBFilterActive%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%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");
}
}
}
}
if (console)
{
/* scope */
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("Available remote USB devices:\n\n");
SafeIfaceArray <IHostUSBDevice> coll;
CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (ComSafeArrayAsOutParam(coll)), rc);
if (coll.size() == 0)
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("<none>\n\n");
}
else
{
for (size_t index = 0; index < coll.size(); ++index)
{
ComPtr <IHostUSBDevice> dev = coll[index];
/* Query info. */
Bstr 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%zu=\"%S\"\n"
"USBRemoteVendorId%zu=\"%#06x\"\n"
"USBRemoteProductId%zu=\"%#06x\"\n"
"USBRemoteRevision%zu=\"%#04x%02x\"\n",
index + 1, Utf8Str(id).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",
Utf8Str(id).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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%lS\"\n", index + 1, bstr.raw());
else
RTPrintf("Address: %lS\n", bstr.raw());
}
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\n");
}
}
}
/* scope */
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf ("Currently Attached USB Devices:\n\n");
SafeIfaceArray <IUSBDevice> coll;
CHECK_ERROR_RET (console, COMGETTER(USBDevices) (ComSafeArrayAsOutParam(coll)), rc);
if (coll.size() == 0)
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("<none>\n\n");
}
else
{
for (size_t index = 0; index < coll.size(); ++index)
{
ComPtr <IUSBDevice> dev = coll[index];
/* Query info. */
Bstr 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%zu=\"%S\"\n"
"USBAttachedVendorId%zu=\"%#06x\"\n"
"USBAttachedProductId%zu=\"%#06x\"\n"
"USBAttachedRevision%zu=\"%#04x%02x\"\n",
index + 1, Utf8Str(id).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",
Utf8Str(id).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%zu=\"%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%zu=\"%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%zu=\"%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%zu=\"%lS\"\n", index + 1, bstr.raw());
else
RTPrintf("Address: %lS\n", bstr.raw());
}
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\n");
}
}
}
}
} /* USB */
/*
* Shared folders
*/
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("Shared folders: ");
uint32_t numSharedFolders = 0;
#if 0 // not yet implemented
/* globally shared folders first */
{
SafeIfaceArray <ISharedFolder> sfColl;
CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc);
for (size_t i = 0; i < sfColl.size(); ++i)
{
ComPtr<ISharedFolder> sf = sfColl[i];
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;
}
}
#endif
/* now VM mappings */
{
com::SafeIfaceArray <ISharedFolder> folders;
CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
for (size_t i = 0; i < folders.size(); ++i)
{
ComPtr <ISharedFolder> sf = folders[i];
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%zu=\"%lS\"\n", i + 1,
name.raw());
RTPrintf("SharedFolderPathMachineMapping%zu=\"%lS\"\n", i + 1,
hostPath.raw());
}
else
RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
++numSharedFolders;
}
}
/* transient mappings */
if (console)
{
com::SafeIfaceArray <ISharedFolder> folders;
CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
for (size_t i = 0; i < folders.size(); ++i)
{
ComPtr <ISharedFolder> sf = folders[i];
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%zu=\"%lS\"\n", i + 1,
name.raw());
RTPrintf("SharedFolderPathTransientMapping%zu=\"%lS\"\n", i + 1,
hostPath.raw());
}
else
RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());
++numSharedFolders;
}
}
if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
RTPrintf("<none>\n");
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\n");
if (console)
{
/*
* Live VRDP info.
*/
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);
}
uint64_t ThroughputSend = 0;
uint64_t ThroughputReceive = 0;
if (EndTime != BeginTime)
{
ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime);
ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
}
if (details == VMINFO_MACHINEREADABLE)
{
RTPrintf("VRDPBytesSent=%llu\n", BytesSent);
RTPrintf("VRDPThroughputSend=%llu\n", ThroughputSend);
RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);
RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);
RTPrintf("VRDPThroughputReceive=%llu\n", ThroughputReceive);
RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);
}
else
{
RTPrintf("Sent: %llu Bytes\n", BytesSent);
RTPrintf("Average speed: %llu B/s\n", ThroughputSend);
RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);
RTPrintf("Received: %llu Bytes\n", BytesReceived);
RTPrintf("Speed: %llu B/s\n", ThroughputReceive);
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");
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);
}
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\n");
/*
* snapshots
*/
ComPtr<ISnapshot> snapshot;
rc = machine->GetSnapshot(Bstr(), snapshot.asOutParam());
if (SUCCEEDED(rc) && snapshot)
{
ComPtr<ISnapshot> currentSnapshot;
rc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam());
if (SUCCEEDED(rc))
{
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("Snapshots:\n\n");
showSnapshots(snapshot, currentSnapshot, details);
}
}
if (details != VMINFO_MACHINEREADABLE)
RTPrintf("\n");
return S_OK;
}
#if defined(_MSC_VER)
# pragma optimize("", on)
#endif
static const RTGETOPTDEF g_aShowVMInfoOptions[] =
{
{ "--details", 'D', RTGETOPT_REQ_NOTHING },
{ "-details", 'D', RTGETOPT_REQ_NOTHING }, // deprecated
{ "--machinereadable", 'M', RTGETOPT_REQ_NOTHING },
{ "-machinereadable", 'M', RTGETOPT_REQ_NOTHING }, // deprecated
{ "--log", 'l', RTGETOPT_REQ_UINT32 },
};
int handleShowVMInfo(HandlerArg *a)
{
HRESULT rc;
const char *VMNameOrUuid = NULL;
bool fLog = false;
uint32_t uLogIdx = 0;
bool fDetails = false;
bool fMachinereadable = false;
int c;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
// start at 0 because main() has hacked both the argc and argv given to us
RTGetOptInit(&GetState, a->argc, a->argv, g_aShowVMInfoOptions, RT_ELEMENTS(g_aShowVMInfoOptions),
0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((c = RTGetOpt(&GetState, &ValueUnion)))
{
switch (c)
{
case 'D': // --details
fDetails = true;
break;
case 'M': // --machinereadable
fMachinereadable = true;
break;
case 'l': // --log
fLog = true;
uLogIdx = ValueUnion.u32;
break;
case VINF_GETOPT_NOT_OPTION:
if (!VMNameOrUuid)
VMNameOrUuid = ValueUnion.psz;
else
return errorSyntax(USAGE_SHOWVMINFO, "Invalid parameter '%s'", ValueUnion.psz);
break;
default:
if (c > 0)
{
if (RT_C_IS_PRINT(c))
return errorSyntax(USAGE_SHOWVMINFO, "Invalid option -%c", c);
else
return errorSyntax(USAGE_SHOWVMINFO, "Invalid option case %i", c);
}
else if (c == VERR_GETOPT_UNKNOWN_OPTION)
return errorSyntax(USAGE_SHOWVMINFO, "unknown option: %s\n", ValueUnion.psz);
else if (ValueUnion.pDef)
return errorSyntax(USAGE_SHOWVMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
else
return errorSyntax(USAGE_SHOWVMINFO, "error: %Rrs", c);
}
}
/* check for required options */
if (!VMNameOrUuid)
return errorSyntax(USAGE_SHOWVMINFO, "VM name or UUID required");
/* try to find the given machine */
ComPtr <IMachine> machine;
Bstr uuid(VMNameOrUuid);
if (!Guid(VMNameOrUuid).isEmpty())
{
CHECK_ERROR(a->virtualBox, GetMachine(uuid, machine.asOutParam()));
}
else
{
CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid), machine.asOutParam()));
if (SUCCEEDED(rc))
machine->COMGETTER(Id)(uuid.asOutParam());
}
if (FAILED(rc))
return 1;
/* Printing the log is exclusive. */
if (fLog && (fMachinereadable || fDetails))
return errorSyntax(USAGE_SHOWVMINFO, "Option --log is exclusive");
if (fLog)
{
ULONG64 uOffset = 0;
SafeArray<BYTE> aLogData;
ULONG cbLogData;
while (true)
{
/* Reset the array */
aLogData.setNull();
/* Fetch a chunk of the log file */
CHECK_ERROR_BREAK(machine, ReadLog(uLogIdx, uOffset, _1M,
ComSafeArrayAsOutParam(aLogData)));
cbLogData = aLogData.size();
if (cbLogData == 0)
break;
/* aLogData has a platform dependent line ending, standardize on
* Unix style, as RTStrmWrite does the LF -> CR/LF replacement on
* Windows. Otherwise we end up with CR/CR/LF on Windows. */
ULONG cbLogDataPrint = cbLogData;
for (BYTE *s = aLogData.raw(), *d = s;
s - aLogData.raw() < (ssize_t)cbLogData;
s++, d++)
{
if (*s == '\r')
{
/* skip over CR, adjust destination */
d--;
cbLogDataPrint--;
}
else if (s != d)
*d = *s;
}
RTStrmWrite(g_pStdOut, aLogData.raw(), cbLogDataPrint);
uOffset += cbLogData;
}
}
else
{
/* 2nd option can be -details or -argdump */
VMINFO_DETAILS details = VMINFO_NONE;
if (fMachinereadable)
details = VMINFO_MACHINEREADABLE;
else if (fDetails)
details = VMINFO_FULL;
else
details = VMINFO_STANDARD;
ComPtr <IConsole> console;
/* open an existing session for the VM */
rc = a->virtualBox->OpenExistingSession(a->session, uuid);
if (SUCCEEDED(rc))
/* get the session machine */
rc = a->session->COMGETTER(Machine)(machine.asOutParam());
if (SUCCEEDED(rc))
/* get the session console */
rc = a->session->COMGETTER(Console)(console.asOutParam());
rc = showVMInfo(a->virtualBox, machine, details, console);
if (console)
a->session->Close();
}
return SUCCEEDED(rc) ? 0 : 1;
}
#endif /* !VBOX_ONLY_DOCS */
/* vi: set tabstop=4 shiftwidth=4 expandtab: */