VBoxManageInfo.cpp@ 55134

Last change on this file since 55134 was 54911, checked in by vboxsync, 10 years ago
Main: Added paravirt. provider KVM APIs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 112.9 KB

Line
1	/* $Id: VBoxManageInfo.cpp 54911 2015-03-23 17:24:33Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'showvminfo' command and helper routines.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef VBOX_ONLY_DOCS
19
20	/*******************************************************************************
21	* Header Files *
22	*******************************************************************************/
23	#include <VBox/com/com.h>
24	#include <VBox/com/string.h>
25	#include <VBox/com/Guid.h>
26	#include <VBox/com/array.h>
27	#include <VBox/com/ErrorInfo.h>
28	#include <VBox/com/errorprint.h>
29
30	#include <VBox/com/VirtualBox.h>
31
32	#ifdef VBOX_WITH_PCI_PASSTHROUGH
33	#include <VBox/pci.h>
34	#endif
35
36	#include <VBox/log.h>
37	#include <iprt/stream.h>
38	#include <iprt/time.h>
39	#include <iprt/string.h>
40	#include <iprt/getopt.h>
41	#include <iprt/ctype.h>
42
43	#include "VBoxManage.h"
44	using namespace com;
45
46
47	// funcs
48	///////////////////////////////////////////////////////////////////////////////
49
50	HRESULT showSnapshots(ComPtr<ISnapshot> &rootSnapshot,
51	ComPtr<ISnapshot> &currentSnapshot,
52	VMINFO_DETAILS details,
53	const Utf8Str &prefix /* = ""*/,
54	int level /= 0/)
55	{
56	/* start with the root */
57	Bstr name;
58	Bstr uuid;
59	Bstr description;
60	CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Name)(name.asOutParam()), hrcCheck);
61	CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Id)(uuid.asOutParam()), hrcCheck);
62	CHECK_ERROR2_RET(rootSnapshot, COMGETTER(Description)(description.asOutParam()), hrcCheck);
63	bool fCurrent = (rootSnapshot == currentSnapshot);
64	if (details == VMINFO_MACHINEREADABLE)
65	{
66	/* print with hierarchical numbering */
67	RTPrintf("SnapshotName%s=\"%ls\"\n", prefix.c_str(), name.raw());
68	RTPrintf("SnapshotUUID%s=\"%s\"\n", prefix.c_str(), Utf8Str(uuid).c_str());
69	if (!description.isEmpty())
70	RTPrintf("SnapshotDescription%s=\"%ls\"\n", prefix.c_str(), description.raw());
71	if (fCurrent)
72	{
73	RTPrintf("CurrentSnapshotName=\"%ls\"\n", name.raw());
74	RTPrintf("CurrentSnapshotUUID=\"%s\"\n", Utf8Str(uuid).c_str());
75	RTPrintf("CurrentSnapshotNode=\"SnapshotName%s\"\n", prefix.c_str());
76	}
77	}
78	else
79	{
80	/* print with indentation */
81	RTPrintf(" %sName: %ls (UUID: %s)%s\n",
82	prefix.c_str(),
83	name.raw(),
84	Utf8Str(uuid).c_str(),
85	(fCurrent) ? " *" : "");
86	if (!description.isEmpty())
87	RTPrintf(" %sDescription:\n%ls\n", prefix.c_str(), description.raw());
88	}
89
90	/* get the children */
91	HRESULT hrc = S_OK;
92	SafeIfaceArray <ISnapshot> coll;
93	CHECK_ERROR2_RET(rootSnapshot,COMGETTER(Children)(ComSafeArrayAsOutParam(coll)), hrcCheck);
94	if (!coll.isNull())
95	{
96	for (size_t index = 0; index < coll.size(); ++index)
97	{
98	ComPtr<ISnapshot> snapshot = coll[index];
99	if (snapshot)
100	{
101	Utf8Str newPrefix;
102	if (details == VMINFO_MACHINEREADABLE)
103	newPrefix = Utf8StrFmt("%s-%d", prefix.c_str(), index + 1);
104	else
105	{
106	newPrefix = Utf8StrFmt("%s ", prefix.c_str());
107	}
108
109	/* recursive call */
110	HRESULT hrc2 = showSnapshots(snapshot, currentSnapshot, details, newPrefix, level + 1);
111	if (FAILED(hrc2))
112	hrc = hrc2;
113	}
114	}
115	}
116	return hrc;
117	}
118
119	static void makeTimeStr(char *s, int cb, int64_t millies)
120	{
121	RTTIME t;
122	RTTIMESPEC ts;
123
124	RTTimeSpecSetMilli(&ts, millies);
125
126	RTTimeExplode(&t, &ts);
127
128	RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
129	t.i32Year, t.u8Month, t.u8MonthDay,
130	t.u8Hour, t.u8Minute, t.u8Second);
131	}
132
133	const char *machineStateToName(MachineState_T machineState, bool fShort)
134	{
135	switch (machineState)
136	{
137	case MachineState_PoweredOff:
138	return fShort ? "poweroff" : "powered off";
139	case MachineState_Saved:
140	return "saved";
141	case MachineState_Aborted:
142	return "aborted";
143	case MachineState_Teleported:
144	return "teleported";
145	case MachineState_Running:
146	return "running";
147	case MachineState_Paused:
148	return "paused";
149	case MachineState_Stuck:
150	return fShort ? "gurumeditation" : "guru meditation";
151	case MachineState_LiveSnapshotting:
152	return fShort ? "livesnapshotting" : "live snapshotting";
153	case MachineState_Teleporting:
154	return "teleporting";
155	case MachineState_Starting:
156	return "starting";
157	case MachineState_Stopping:
158	return "stopping";
159	case MachineState_Saving:
160	return "saving";
161	case MachineState_Restoring:
162	return "restoring";
163	case MachineState_TeleportingPausedVM:
164	return fShort ? "teleportingpausedvm" : "teleporting paused vm";
165	case MachineState_TeleportingIn:
166	return fShort ? "teleportingin" : "teleporting (incoming)";
167	case MachineState_RestoringSnapshot:
168	return fShort ? "restoringsnapshot" : "restoring snapshot";
169	case MachineState_DeletingSnapshot:
170	return fShort ? "deletingsnapshot" : "deleting snapshot";
171	case MachineState_DeletingSnapshotOnline:
172	return fShort ? "deletingsnapshotlive" : "deleting snapshot live";
173	case MachineState_DeletingSnapshotPaused:
174	return fShort ? "deletingsnapshotlivepaused" : "deleting snapshot live paused";
175	case MachineState_SettingUp:
176	return fShort ? "settingup" : "setting up";
177	default:
178	break;
179	}
180	return "unknown";
181	}
182
183	const char *facilityStateToName(AdditionsFacilityStatus_T faStatus, bool fShort)
184	{
185	switch (faStatus)
186	{
187	case AdditionsFacilityStatus_Inactive:
188	return fShort ? "inactive" : "not active";
189	case AdditionsFacilityStatus_Paused:
190	return "paused";
191	case AdditionsFacilityStatus_PreInit:
192	return fShort ? "preinit" : "pre-initializing";
193	case AdditionsFacilityStatus_Init:
194	return fShort ? "init" : "initializing";
195	case AdditionsFacilityStatus_Active:
196	return fShort ? "active" : "active/running";
197	case AdditionsFacilityStatus_Terminating:
198	return "terminating";
199	case AdditionsFacilityStatus_Terminated:
200	return "terminated";
201	case AdditionsFacilityStatus_Failed:
202	return "failed";
203	case AdditionsFacilityStatus_Unknown:
204	default:
205	break;
206	}
207	return "unknown";
208	}
209
210	/**
211	* This takes care of escaping double quotes and slashes that the string might
212	* contain.
213	*
214	* @param pszName The variable name.
215	* @param pbstrValue The value.
216	*/
217	static void outputMachineReadableString(const char pszName, Bstr const pbstrValue)
218	{
219	Assert(strpbrk(pszName, "\"\\") == NULL);
220
221	com::Utf8Str strValue(*pbstrValue);
222	if ( strValue.isEmpty()
223	\|\| ( !strValue.count('"')
224	&& !strValue.count('\\')))
225	RTPrintf("%s=\"%s\"\n", pszName, strValue.c_str());
226	else
227	{
228	/* The value needs escaping. */
229	RTPrintf("%s=\"", pszName);
230	const char *psz = strValue.c_str();
231	for (;;)
232	{
233	const char *pszNext = strpbrk(psz, "\"\\");
234	if (!pszNext)
235	{
236	RTPrintf("%s", psz);
237	break;
238	}
239	RTPrintf("%.s\\%c", pszNext - psz, psz, pszNext);
240	psz = pszNext + 1;
241	}
242	RTPrintf("\"\n");
243	}
244	}
245
246	/**
247	* Converts bandwidth group type to a string.
248	* @returns String representation.
249	* @param enmType Bandwidth control group type.
250	*/
251	inline const char * bwGroupTypeToString(BandwidthGroupType_T enmType)
252	{
253	switch (enmType)
254	{
255	case BandwidthGroupType_Disk: return "Disk";
256	case BandwidthGroupType_Network: return "Network";
257	}
258	return "unknown";
259	}
260
261	HRESULT showBandwidthGroups(ComPtr<IBandwidthControl> &bwCtrl,
262	VMINFO_DETAILS details)
263	{
264	int rc = S_OK;
265	SafeIfaceArray<IBandwidthGroup> bwGroups;
266
267	CHECK_ERROR_RET(bwCtrl, GetAllBandwidthGroups(ComSafeArrayAsOutParam(bwGroups)), rc);
268
269	if (bwGroups.size() && details != VMINFO_MACHINEREADABLE)
270	RTPrintf("\n\n");
271	for (size_t i = 0; i < bwGroups.size(); i++)
272	{
273	Bstr strName;
274	LONG64 cMaxBytesPerSec;
275	BandwidthGroupType_T enmType;
276
277	CHECK_ERROR_RET(bwGroups[i], COMGETTER(Name)(strName.asOutParam()), rc);
278	CHECK_ERROR_RET(bwGroups[i], COMGETTER(Type)(&enmType), rc);
279	CHECK_ERROR_RET(bwGroups[i], COMGETTER(MaxBytesPerSec)(&cMaxBytesPerSec), rc);
280
281	const char *pszType = bwGroupTypeToString(enmType);
282	if (details == VMINFO_MACHINEREADABLE)
283	RTPrintf("BandwidthGroup%zu=%ls,%s,%lld\n", i, strName.raw(), pszType, cMaxBytesPerSec);
284	else
285	{
286	const char *pszUnits = "";
287	LONG64 cBytes = cMaxBytesPerSec;
288	if (cBytes == 0)
289	{
290	RTPrintf("Name: '%ls', Type: %s, Limit: none (disabled)\n", strName.raw(), pszType);
291	continue;
292	}
293	else if (!(cBytes % _1G))
294	{
295	pszUnits = "G";
296	cBytes /= _1G;
297	}
298	else if (!(cBytes % _1M))
299	{
300	pszUnits = "M";
301	cBytes /= _1M;
302	}
303	else if (!(cBytes % _1K))
304	{
305	pszUnits = "K";
306	cBytes /= _1K;
307	}
308	const char *pszNetUnits = NULL;
309	if (enmType == BandwidthGroupType_Network)
310	{
311	/*
312	* We want to report network rate limit in bits/s, not bytes.
313	* Only if it cannot be express it in kilobits we will fall
314	* back to reporting it in bytes.
315	*/
316	LONG64 cBits = cMaxBytesPerSec;
317	if (!(cBits % 125))
318	{
319	cBits /= 125;
320	pszNetUnits = "k";
321	if (!(cBits % 1000000))
322	{
323	cBits /= 1000000;
324	pszNetUnits = "g";
325	}
326	else if (!(cBits % 1000))
327	{
328	cBits /= 1000;
329	pszNetUnits = "m";
330	}
331	RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbits/sec (%lld %sbytes/sec)\n", strName.raw(), pszType, cBits, pszNetUnits, cBytes, pszUnits);
332	}
333	}
334	if (!pszNetUnits)
335	RTPrintf("Name: '%ls', Type: %s, Limit: %lld %sbytes/sec\n", strName.raw(), pszType, cBytes, pszUnits);
336	}
337	}
338	if (details != VMINFO_MACHINEREADABLE)
339	RTPrintf(bwGroups.size() != 0 ? "\n" : "<none>\n\n");
340
341	return rc;
342	}
343
344
345	/* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable
346	time. MSC 7.1/32 doesn't have quite as much trouble with it, but still
347	sufficient to qualify for this hack as well since this code isn't performance
348	critical and probably won't gain much from the extra optimizing in real life. */
349	#if defined(_MSC_VER)
350	# pragma optimize("g", off)
351	#endif
352
353	HRESULT showVMInfo(ComPtr<IVirtualBox> pVirtualBox,
354	ComPtr<IMachine> machine,
355	ComPtr<ISession> pSession,
356	VMINFO_DETAILS details /= VMINFO_NONE/)
357	{
358	HRESULT rc;
359	ComPtr<IConsole> pConsole;
360	if (pSession)
361	pSession->COMGETTER(Console)(pConsole.asOutParam());
362
363	#define SHOW_BOOLEAN_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
364	SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_szMachine, a_szHuman, "on", "off")
365
366	#define SHOW_BOOLEAN_PROP_EX(a_pObj, a_Prop, a_szMachine, a_szHuman, a_szTrue, a_szFalse) \
367	do \
368	{ \
369	BOOL f; \
370	CHECK_ERROR2_RET(a_pObj, COMGETTER(a_Prop)(&f), hrcCheck); \
371	if (details == VMINFO_MACHINEREADABLE) \
372	RTPrintf( a_szMachine "=\"%s\"\n", f ? "on" : "off"); \
373	else \
374	RTPrintf("%-16s %s\n", a_szHuman ":", f ? a_szTrue : a_szFalse); \
375	} while (0)
376
377	#define SHOW_BOOLEAN_METHOD(a_pObj, a_Invocation, a_szMachine, a_szHuman) \
378	do \
379	{ \
380	BOOL f; \
381	CHECK_ERROR2_RET(a_pObj, a_Invocation, hrcCheck); \
382	if (details == VMINFO_MACHINEREADABLE) \
383	RTPrintf( a_szMachine "=\"%s\"\n", f ? "on" : "off"); \
384	else \
385	RTPrintf("%-16s %s\n", a_szHuman ":", f ? "on" : "off"); \
386	} while (0)
387
388	#define SHOW_STRING_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
389	do \
390	{ \
391	Bstr bstr; \
392	CHECK_ERROR2_RET(a_pObj, COMGETTER(a_Prop)(bstr.asOutParam()), hrcCheck); \
393	if (details == VMINFO_MACHINEREADABLE) \
394	outputMachineReadableString(a_szMachine, &bstr); \
395	else \
396	RTPrintf("%-16s %ls\n", a_szHuman ":", bstr.raw()); \
397	} while (0)
398
399	#define SHOW_STRINGARRAY_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
400	do \
401	{ \
402	SafeArray<BSTR> array; \
403	CHECK_ERROR2_RET(a_pObj, COMGETTER(a_Prop)(ComSafeArrayAsOutParam(array)), hrcCheck); \
404	Utf8Str str; \
405	for (size_t i = 0; i < array.size(); i++) \
406	{ \
407	if (i != 0) \
408	str.append(","); \
409	str.append(Utf8Str(array[i]).c_str()); \
410	} \
411	Bstr bstr(str); \
412	if (details == VMINFO_MACHINEREADABLE) \
413	outputMachineReadableString(a_szMachine, &bstr); \
414	else \
415	RTPrintf("%-16s %ls\n", a_szHuman ":", bstr.raw()); \
416	} while (0)
417
418	#define SHOW_UUID_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
419	SHOW_STRING_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman)
420
421	#define SHOW_ULONG_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman, a_szUnit) \
422	do \
423	{ \
424	ULONG u32; \
425	CHECK_ERROR2_RET(a_pObj, COMGETTER(a_Prop)(&u32), hrcCheck); \
426	if (details == VMINFO_MACHINEREADABLE) \
427	RTPrintf(a_szMachine "=%u\n", u32); \
428	else \
429	RTPrintf("%-16s %u" a_szUnit "\n", a_szHuman ":", u32); \
430	} while (0)
431
432	#define SHOW_LONG64_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman, a_szUnit) \
433	do \
434	{ \
435	LONG64 i64; \
436	CHECK_ERROR2_RET(a_pObj, COMGETTER(a_Prop)(&i64), hrcCheck); \
437	if (details == VMINFO_MACHINEREADABLE) \
438	RTPrintf(a_szMachine "=%lld\n", i64); \
439	else \
440	RTPrintf("%-16s %'lld" a_szUnit "\n", a_szHuman ":", i64); \
441	} while (0)
442
443	/*
444	* The rules for output in -argdump format:
445	* 1) the key part (the [0-9a-zA-Z_\-]+ string before the '=' delimiter)
446	* is all lowercase for "VBoxManage modifyvm" parameters. Any
447	* other values printed are in CamelCase.
448	* 2) strings (anything non-decimal) are printed surrounded by
449	* double quotes '"'. If the strings themselves contain double
450	* quotes, these characters are escaped by '\'. Any '\' character
451	* in the original string is also escaped by '\'.
452	* 3) numbers (containing just [0-9\-]) are written out unchanged.
453	*/
454
455	BOOL fAccessible;
456	CHECK_ERROR2_RET(machine, COMGETTER(Accessible)(&fAccessible), hrcCheck);
457	if (!fAccessible)
458	{
459	Bstr uuid;
460	machine->COMGETTER(Id)(uuid.asOutParam());
461	if (details == VMINFO_COMPACT)
462	RTPrintf("\"<inaccessible>\" {%s}\n", Utf8Str(uuid).c_str());
463	else
464	{
465	if (details == VMINFO_MACHINEREADABLE)
466	RTPrintf("name=\"<inaccessible>\"\n");
467	else
468	RTPrintf("Name: <inaccessible!>\n");
469	if (details == VMINFO_MACHINEREADABLE)
470	RTPrintf("UUID=\"%s\"\n", Utf8Str(uuid).c_str());
471	else
472	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
473	if (details != VMINFO_MACHINEREADABLE)
474	{
475	Bstr settingsFilePath;
476	rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
477	RTPrintf("Config file: %ls\n", settingsFilePath.raw());
478	ComPtr<IVirtualBoxErrorInfo> accessError;
479	rc = machine->COMGETTER(AccessError)(accessError.asOutParam());
480	RTPrintf("Access error details:\n");
481	ErrorInfo ei(accessError);
482	GluePrintErrorInfo(ei);
483	RTPrintf("\n");
484	}
485	}
486	return S_OK;
487	}
488
489	if (details == VMINFO_COMPACT)
490	{
491	Bstr machineName;
492	machine->COMGETTER(Name)(machineName.asOutParam());
493	Bstr uuid;
494	machine->COMGETTER(Id)(uuid.asOutParam());
495
496	RTPrintf("\"%ls\" {%s}\n", machineName.raw(), Utf8Str(uuid).c_str());
497	return S_OK;
498	}
499
500	SHOW_STRING_PROP( machine, Name, "name", "Name");
501
502	Bstr osTypeId;
503	CHECK_ERROR2_RET(machine, COMGETTER(OSTypeId)(osTypeId.asOutParam()), hrcCheck);
504	ComPtr<IGuestOSType> osType;
505	CHECK_ERROR2_RET(pVirtualBox, GetGuestOSType(osTypeId.raw(), osType.asOutParam()), hrcCheck);
506	SHOW_STRINGARRAY_PROP( machine, Groups, "groups", "Groups");
507	SHOW_STRING_PROP( osType, Description, "ostype", "Guest OS");
508	SHOW_UUID_PROP( machine, Id, "UUID", "UUID");
509	SHOW_STRING_PROP( machine, SettingsFilePath, "CfgFile", "Config file");
510	SHOW_STRING_PROP( machine, SnapshotFolder, "SnapFldr", "Snapshot folder");
511	SHOW_STRING_PROP( machine, LogFolder, "LogFldr", "Log folder");
512	SHOW_UUID_PROP( machine, HardwareUUID, "hardwareuuid", "Hardware UUID");
513	SHOW_ULONG_PROP( machine, MemorySize, "memory", "Memory size", "MB");
514	SHOW_BOOLEAN_PROP( machine, PageFusionEnabled, "pagefusion", "Page Fusion");
515	SHOW_ULONG_PROP( machine, VRAMSize, "vram", "VRAM size", "MB");
516	SHOW_ULONG_PROP( machine, CPUExecutionCap, "cpuexecutioncap", "CPU exec cap", "%%");
517	SHOW_BOOLEAN_PROP( machine, HPETEnabled, "hpet", "HPET");
518
519	ChipsetType_T chipsetType;
520	CHECK_ERROR2_RET(machine, COMGETTER(ChipsetType)(&chipsetType), hrcCheck);
521	const char *pszChipsetType;
522	switch (chipsetType)
523	{
524	case ChipsetType_Null: pszChipsetType = "invalid"; break;
525	case ChipsetType_PIIX3: pszChipsetType = "piix3"; break;
526	case ChipsetType_ICH9: pszChipsetType = "ich9"; break;
527	default: AssertFailed(); pszChipsetType = "unknown"; break;
528	}
529	if (details == VMINFO_MACHINEREADABLE)
530	RTPrintf("chipset=\"%s\"\n", pszChipsetType);
531	else
532	RTPrintf("Chipset: %s\n", pszChipsetType);
533
534	FirmwareType_T firmwareType;
535	CHECK_ERROR2_RET(machine, COMGETTER(FirmwareType)(&firmwareType), hrcCheck);
536	const char *pszFirmwareType;
537	switch (firmwareType)
538	{
539	case FirmwareType_BIOS: pszFirmwareType = "BIOS"; break;
540	case FirmwareType_EFI: pszFirmwareType = "EFI"; break;
541	case FirmwareType_EFI32: pszFirmwareType = "EFI32"; break;
542	case FirmwareType_EFI64: pszFirmwareType = "EFI64"; break;
543	case FirmwareType_EFIDUAL: pszFirmwareType = "EFIDUAL"; break;
544	default: AssertFailed(); pszFirmwareType = "unknown"; break;
545	}
546	if (details == VMINFO_MACHINEREADABLE)
547	RTPrintf("firmware=\"%s\"\n", pszFirmwareType);
548	else
549	RTPrintf("Firmware: %s\n", pszFirmwareType);
550
551	SHOW_ULONG_PROP( machine, CPUCount, "cpus", "Number of CPUs", "");
552	SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_PAE, &f), "pae", "PAE");
553	SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_LongMode, &f), "longmode", "Long Mode");
554	SHOW_BOOLEAN_METHOD( machine, GetCPUProperty(CPUPropertyType_Synthetic, &f), "synthcpu", "Synthetic CPU");
555
556	if (details != VMINFO_MACHINEREADABLE)
557	RTPrintf("CPUID overrides: ");
558	ULONG cFound = 0;
559	static uint32_t const s_auCpuIdRanges[] =
560	{
561	UINT32_C(0x00000000), UINT32_C(0x0000000a),
562	UINT32_C(0x80000000), UINT32_C(0x8000000a)
563	};
564	for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
565	for (uint32_t uLeaf = s_auCpuIdRanges[i]; uLeaf < s_auCpuIdRanges[i + 1]; uLeaf++)
566	{
567	ULONG uEAX, uEBX, uECX, uEDX;
568	rc = machine->GetCPUIDLeaf(uLeaf, &uEAX, &uEBX, &uECX, &uEDX);
569	if (SUCCEEDED(rc))
570	{
571	if (details == VMINFO_MACHINEREADABLE)
572	RTPrintf("cpuid=%08x,%08x,%08x,%08x,%08x", uLeaf, uEAX, uEBX, uECX, uEDX);
573	else
574	{
575	if (!cFound)
576	RTPrintf("Leaf no. EAX EBX ECX EDX\n");
577	RTPrintf(" %08x %08x %08x %08x %08x\n", uLeaf, uEAX, uEBX, uECX, uEDX);
578	}
579	cFound++;
580	}
581	}
582	if (!cFound && details != VMINFO_MACHINEREADABLE)
583	RTPrintf("None\n");
584
585	ComPtr<IBIOSSettings> biosSettings;
586	CHECK_ERROR2_RET(machine, COMGETTER(BIOSSettings)(biosSettings.asOutParam()), hrcCheck);
587
588	BIOSBootMenuMode_T bootMenuMode;
589	CHECK_ERROR2_RET(biosSettings, COMGETTER(BootMenuMode)(&bootMenuMode), hrcCheck);
590	const char *pszBootMenu;
591	switch (bootMenuMode)
592	{
593	case BIOSBootMenuMode_Disabled:
594	pszBootMenu = "disabled";
595	break;
596	case BIOSBootMenuMode_MenuOnly:
597	if (details == VMINFO_MACHINEREADABLE)
598	pszBootMenu = "menuonly";
599	else
600	pszBootMenu = "menu only";
601	break;
602	default:
603	if (details == VMINFO_MACHINEREADABLE)
604	pszBootMenu = "messageandmenu";
605	else
606	pszBootMenu = "message and menu";
607	}
608	if (details == VMINFO_MACHINEREADABLE)
609	RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);
610	else
611	RTPrintf("Boot menu mode: %s\n", pszBootMenu);
612
613	ComPtr<ISystemProperties> systemProperties;
614	CHECK_ERROR2_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
615	ULONG maxBootPosition = 0;
616	CHECK_ERROR2_RET(systemProperties, COMGETTER(MaxBootPosition)(&maxBootPosition), hrcCheck);
617	for (ULONG i = 1; i <= maxBootPosition; i++)
618	{
619	DeviceType_T bootOrder;
620	CHECK_ERROR2_RET(machine, GetBootOrder(i, &bootOrder), hrcCheck);
621	if (bootOrder == DeviceType_Floppy)
622	{
623	if (details == VMINFO_MACHINEREADABLE)
624	RTPrintf("boot%d=\"floppy\"\n", i);
625	else
626	RTPrintf("Boot Device (%d): Floppy\n", i);
627	}
628	else if (bootOrder == DeviceType_DVD)
629	{
630	if (details == VMINFO_MACHINEREADABLE)
631	RTPrintf("boot%d=\"dvd\"\n", i);
632	else
633	RTPrintf("Boot Device (%d): DVD\n", i);
634	}
635	else if (bootOrder == DeviceType_HardDisk)
636	{
637	if (details == VMINFO_MACHINEREADABLE)
638	RTPrintf("boot%d=\"disk\"\n", i);
639	else
640	RTPrintf("Boot Device (%d): HardDisk\n", i);
641	}
642	else if (bootOrder == DeviceType_Network)
643	{
644	if (details == VMINFO_MACHINEREADABLE)
645	RTPrintf("boot%d=\"net\"\n", i);
646	else
647	RTPrintf("Boot Device (%d): Network\n", i);
648	}
649	else if (bootOrder == DeviceType_USB)
650	{
651	if (details == VMINFO_MACHINEREADABLE)
652	RTPrintf("boot%d=\"usb\"\n", i);
653	else
654	RTPrintf("Boot Device (%d): USB\n", i);
655	}
656	else if (bootOrder == DeviceType_SharedFolder)
657	{
658	if (details == VMINFO_MACHINEREADABLE)
659	RTPrintf("boot%d=\"sharedfolder\"\n", i);
660	else
661	RTPrintf("Boot Device (%d): Shared Folder\n", i);
662	}
663	else
664	{
665	if (details == VMINFO_MACHINEREADABLE)
666	RTPrintf("boot%d=\"none\"\n", i);
667	else
668	RTPrintf("Boot Device (%d): Not Assigned\n", i);
669	}
670	}
671
672	SHOW_BOOLEAN_PROP(biosSettings, ACPIEnabled, "acpi", "ACPI");
673	SHOW_BOOLEAN_PROP(biosSettings, IOAPICEnabled, "ioapic", "IOAPIC");
674	SHOW_LONG64_PROP(biosSettings, TimeOffset, "biossystemtimeoffset", "Time offset", "ms");
675	SHOW_BOOLEAN_PROP_EX(machine, RTCUseUTC, "rtcuseutc", "RTC", "UTC", "local time");
676	SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_Enabled, &f), "hwvirtex", "Hardw. virt.ext");
677	SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &f),"nestedpaging", "Nested Paging");
678	SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &f), "largepages", "Large Pages");
679	SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_VPID, &f), "vtxvpid", "VT-x VPID");
680	SHOW_BOOLEAN_METHOD(machine, GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &f), "vtxux", "VT-x unr. exec.");
681
682	ParavirtProvider_T paravirtProvider;
683	CHECK_ERROR2_RET(machine, COMGETTER(ParavirtProvider)(&paravirtProvider), hrcCheck);
684	const char *pszParavirtProvider;
685	switch (paravirtProvider)
686	{
687	case ParavirtProvider_None:
688	if (details == VMINFO_MACHINEREADABLE)
689	pszParavirtProvider = "none";
690	else
691	pszParavirtProvider = "None";
692	break;
693
694	case ParavirtProvider_Default:
695	if (details == VMINFO_MACHINEREADABLE)
696	pszParavirtProvider = "default";
697	else
698	pszParavirtProvider = "Default";
699	break;
700
701	case ParavirtProvider_Legacy:
702	if (details == VMINFO_MACHINEREADABLE)
703	pszParavirtProvider = "legacy";
704	else
705	pszParavirtProvider = "Legacy";
706	break;
707
708	case ParavirtProvider_Minimal:
709	if (details == VMINFO_MACHINEREADABLE)
710	pszParavirtProvider = "minimal";
711	else
712	pszParavirtProvider = "Minimal";
713	break;
714
715	case ParavirtProvider_HyperV:
716	if (details == VMINFO_MACHINEREADABLE)
717	pszParavirtProvider = "hyperv";
718	else
719	pszParavirtProvider = "HyperV";
720	break;
721
722	case ParavirtProvider_KVM:
723	if (details == VMINFO_MACHINEREADABLE)
724	pszParavirtProvider = "kvm";
725	else
726	pszParavirtProvider = "KVM";
727	break;
728
729	default:
730	if (details == VMINFO_MACHINEREADABLE)
731	pszParavirtProvider = "unknown";
732	else
733	pszParavirtProvider = "Unknown";
734	}
735	if (details == VMINFO_MACHINEREADABLE)
736	RTPrintf("paravirtprovider=\"%s\"\n", pszParavirtProvider);
737	else
738	RTPrintf("Paravirt. Provider: %s\n", pszParavirtProvider);
739
740
741	MachineState_T machineState;
742	CHECK_ERROR2_RET(machine, COMGETTER(State)(&machineState), hrcCheck);
743	const char pszState = machineStateToName(machineState, details == VMINFO_MACHINEREADABLE /=fShort*/);
744
745	LONG64 stateSince;
746	machine->COMGETTER(LastStateChange)(&stateSince);
747	RTTIMESPEC timeSpec;
748	RTTimeSpecSetMilli(&timeSpec, stateSince);
749	char pszTime[30] = {0};
750	RTTimeSpecToString(&timeSpec, pszTime, sizeof(pszTime));
751	if (details == VMINFO_MACHINEREADABLE)
752	{
753	RTPrintf("VMState=\"%s\"\n", pszState);
754	RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime);
755
756	Bstr stateFile;
757	machine->COMGETTER(StateFilePath)(stateFile.asOutParam());
758	if (!stateFile.isEmpty())
759	RTPrintf("VMStateFile=\"%ls\"\n", stateFile.raw());
760	}
761	else
762	RTPrintf("State: %s (since %s)\n", pszState, pszTime);
763
764	SHOW_ULONG_PROP( machine, MonitorCount, "monitorcount", "Monitor count", "");
765	SHOW_BOOLEAN_PROP( machine, Accelerate3DEnabled, "accelerate3d", "3D Acceleration");
766	#ifdef VBOX_WITH_VIDEOHWACCEL
767	SHOW_BOOLEAN_PROP( machine, Accelerate2DVideoEnabled, "accelerate2dvideo", "2D Video Acceleration");
768	#endif
769	SHOW_BOOLEAN_PROP( machine, TeleporterEnabled, "teleporterenabled", "Teleporter Enabled");
770	SHOW_ULONG_PROP( machine, TeleporterPort, "teleporterport", "Teleporter Port", "");
771	SHOW_STRING_PROP( machine, TeleporterAddress, "teleporteraddress", "Teleporter Address");
772	SHOW_STRING_PROP( machine, TeleporterPassword, "teleporterpassword", "Teleporter Password");
773	SHOW_BOOLEAN_PROP( machine, TracingEnabled, "tracing-enabled", "Tracing Enabled");
774	SHOW_BOOLEAN_PROP( machine, AllowTracingToAccessVM, "tracing-allow-vm-access", "Allow Tracing to Access VM");
775	SHOW_STRING_PROP( machine, TracingConfig, "tracing-config", "Tracing Configuration");
776	SHOW_BOOLEAN_PROP( machine, AutostartEnabled, "autostart-enabled", "Autostart Enabled");
777	SHOW_ULONG_PROP( machine, AutostartDelay, "autostart-delay", "Autostart Delay", "");
778	SHOW_STRING_PROP( machine, DefaultFrontend, "defaultfrontend", "Default Frontend");
779
780	/** @todo Convert the remainder of the function to SHOW_XXX macros and add error
781	* checking where missing. */
782	/*
783	* Storage Controllers and their attached Mediums.
784	*/
785	com::SafeIfaceArray<IStorageController> storageCtls;
786	CHECK_ERROR(machine, COMGETTER(StorageControllers)(ComSafeArrayAsOutParam(storageCtls)));
787	for (size_t i = 0; i < storageCtls.size(); ++ i)
788	{
789	ComPtr<IStorageController> storageCtl = storageCtls[i];
790	StorageControllerType_T enmCtlType = StorageControllerType_Null;
791	const char *pszCtl = NULL;
792	ULONG ulValue = 0;
793	BOOL fBootable = FALSE;
794	Bstr storageCtlName;
795
796	storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
797	if (details == VMINFO_MACHINEREADABLE)
798	RTPrintf("storagecontrollername%u=\"%ls\"\n", i, storageCtlName.raw());
799	else
800	RTPrintf("Storage Controller Name (%u): %ls\n", i, storageCtlName.raw());
801
802	storageCtl->COMGETTER(ControllerType)(&enmCtlType);
803	switch (enmCtlType)
804	{
805	case StorageControllerType_LsiLogic:
806	pszCtl = "LsiLogic";
807	break;
808	case StorageControllerType_LsiLogicSas:
809	pszCtl = "LsiLogicSas";
810	break;
811	case StorageControllerType_BusLogic:
812	pszCtl = "BusLogic";
813	break;
814	case StorageControllerType_IntelAhci:
815	pszCtl = "IntelAhci";
816	break;
817	case StorageControllerType_PIIX3:
818	pszCtl = "PIIX3";
819	break;
820	case StorageControllerType_PIIX4:
821	pszCtl = "PIIX4";
822	break;
823	case StorageControllerType_ICH6:
824	pszCtl = "ICH6";
825	break;
826	case StorageControllerType_I82078:
827	pszCtl = "I82078";
828	break;
829	case StorageControllerType_USB:
830	pszCtl = "USB";
831	break;
832
833	default:
834	pszCtl = "unknown";
835	}
836	if (details == VMINFO_MACHINEREADABLE)
837	RTPrintf("storagecontrollertype%u=\"%s\"\n", i, pszCtl);
838	else
839	RTPrintf("Storage Controller Type (%u): %s\n", i, pszCtl);
840
841	storageCtl->COMGETTER(Instance)(&ulValue);
842	if (details == VMINFO_MACHINEREADABLE)
843	RTPrintf("storagecontrollerinstance%u=\"%lu\"\n", i, ulValue);
844	else
845	RTPrintf("Storage Controller Instance Number (%u): %lu\n", i, ulValue);
846
847	storageCtl->COMGETTER(MaxPortCount)(&ulValue);
848	if (details == VMINFO_MACHINEREADABLE)
849	RTPrintf("storagecontrollermaxportcount%u=\"%lu\"\n", i, ulValue);
850	else
851	RTPrintf("Storage Controller Max Port Count (%u): %lu\n", i, ulValue);
852
853	storageCtl->COMGETTER(PortCount)(&ulValue);
854	if (details == VMINFO_MACHINEREADABLE)
855	RTPrintf("storagecontrollerportcount%u=\"%lu\"\n", i, ulValue);
856	else
857	RTPrintf("Storage Controller Port Count (%u): %lu\n", i, ulValue);
858
859	storageCtl->COMGETTER(Bootable)(&fBootable);
860	if (details == VMINFO_MACHINEREADABLE)
861	RTPrintf("storagecontrollerbootable%u=\"%s\"\n", i, fBootable ? "on" : "off");
862	else
863	RTPrintf("Storage Controller Bootable (%u): %s\n", i, fBootable ? "on" : "off");
864	}
865
866	for (size_t j = 0; j < storageCtls.size(); ++ j)
867	{
868	ComPtr<IStorageController> storageCtl = storageCtls[j];
869	ComPtr<IMedium> medium;
870	Bstr storageCtlName;
871	Bstr filePath;
872	ULONG cDevices;
873	ULONG cPorts;
874
875	storageCtl->COMGETTER(Name)(storageCtlName.asOutParam());
876	storageCtl->COMGETTER(MaxDevicesPerPortCount)(&cDevices);
877	storageCtl->COMGETTER(PortCount)(&cPorts);
878
879	for (ULONG i = 0; i < cPorts; ++ i)
880	{
881	for (ULONG k = 0; k < cDevices; ++ k)
882	{
883	ComPtr<IMediumAttachment> mediumAttach;
884	machine->GetMediumAttachment(storageCtlName.raw(),
885	i, k,
886	mediumAttach.asOutParam());
887	BOOL fIsEjected = FALSE;
888	BOOL fTempEject = FALSE;
889	DeviceType_T devType = DeviceType_Null;
890	if (mediumAttach)
891	{
892	mediumAttach->COMGETTER(TemporaryEject)(&fTempEject);
893	mediumAttach->COMGETTER(IsEjected)(&fIsEjected);
894	mediumAttach->COMGETTER(Type)(&devType);
895	}
896	rc = machine->GetMedium(storageCtlName.raw(), i, k,
897	medium.asOutParam());
898	if (SUCCEEDED(rc) && medium)
899	{
900	BOOL fPassthrough = FALSE;
901
902	if (mediumAttach)
903	mediumAttach->COMGETTER(Passthrough)(&fPassthrough);
904
905	medium->COMGETTER(Location)(filePath.asOutParam());
906	Bstr uuid;
907	medium->COMGETTER(Id)(uuid.asOutParam());
908
909	if (details == VMINFO_MACHINEREADABLE)
910	{
911	RTPrintf("\"%ls-%d-%d\"=\"%ls\"\n", storageCtlName.raw(),
912	i, k, filePath.raw());
913	RTPrintf("\"%ls-ImageUUID-%d-%d\"=\"%s\"\n",
914	storageCtlName.raw(), i, k, Utf8Str(uuid).c_str());
915	if (fPassthrough)
916	RTPrintf("\"%ls-dvdpassthrough\"=\"%s\"\n", storageCtlName.raw(),
917	fPassthrough ? "on" : "off");
918	if (devType == DeviceType_DVD)
919	{
920	RTPrintf("\"%ls-tempeject\"=\"%s\"\n", storageCtlName.raw(),
921	fTempEject ? "on" : "off");
922	RTPrintf("\"%ls-IsEjected\"=\"%s\"\n", storageCtlName.raw(),
923	fIsEjected ? "on" : "off");
924	}
925	}
926	else
927	{
928	RTPrintf("%ls (%d, %d): %ls (UUID: %s)",
929	storageCtlName.raw(), i, k, filePath.raw(),
930	Utf8Str(uuid).c_str());
931	if (fPassthrough)
932	RTPrintf(" (passthrough enabled)");
933	if (fTempEject)
934	RTPrintf(" (temp eject)");
935	if (fIsEjected)
936	RTPrintf(" (ejected)");
937	RTPrintf("\n");
938	}
939	}
940	else if (SUCCEEDED(rc))
941	{
942	if (details == VMINFO_MACHINEREADABLE)
943	{
944	RTPrintf("\"%ls-%d-%d\"=\"emptydrive\"\n", storageCtlName.raw(), i, k);
945	if (devType == DeviceType_DVD)
946	RTPrintf("\"%ls-IsEjected\"=\"%s\"\n", storageCtlName.raw(),
947	fIsEjected ? "on" : "off");
948	}
949	else
950	{
951	RTPrintf("%ls (%d, %d): Empty", storageCtlName.raw(), i, k);
952	if (fTempEject)
953	RTPrintf(" (temp eject)");
954	if (fIsEjected)
955	RTPrintf(" (ejected)");
956	RTPrintf("\n");
957	}
958	}
959	else
960	{
961	if (details == VMINFO_MACHINEREADABLE)
962	RTPrintf("\"%ls-%d-%d\"=\"none\"\n", storageCtlName.raw(), i, k);
963	}
964	}
965	}
966	}
967
968	/* get the maximum amount of NICS */
969	ULONG maxNICs = getMaxNics(pVirtualBox, machine);
970
971	for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)
972	{
973	ComPtr<INetworkAdapter> nic;
974	rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
975	if (SUCCEEDED(rc) && nic)
976	{
977	BOOL fEnabled;
978	nic->COMGETTER(Enabled)(&fEnabled);
979	if (!fEnabled)
980	{
981	if (details == VMINFO_MACHINEREADABLE)
982	RTPrintf("nic%d=\"none\"\n", currentNIC + 1);
983	else
984	RTPrintf("NIC %d: disabled\n", currentNIC + 1);
985	}
986	else
987	{
988	Bstr strMACAddress;
989	nic->COMGETTER(MACAddress)(strMACAddress.asOutParam());
990	Utf8Str strAttachment;
991	Utf8Str strNatSettings = "";
992	Utf8Str strNatForwardings = "";
993	NetworkAttachmentType_T attachment;
994	nic->COMGETTER(AttachmentType)(&attachment);
995	switch (attachment)
996	{
997	case NetworkAttachmentType_Null:
998	if (details == VMINFO_MACHINEREADABLE)
999	strAttachment = "null";
1000	else
1001	strAttachment = "none";
1002	break;
1003
1004	case NetworkAttachmentType_NAT:
1005	{
1006	Bstr strNetwork;
1007	ComPtr<INATEngine> engine;
1008	nic->COMGETTER(NATEngine)(engine.asOutParam());
1009	engine->COMGETTER(Network)(strNetwork.asOutParam());
1010	com::SafeArray<BSTR> forwardings;
1011	engine->COMGETTER(Redirects)(ComSafeArrayAsOutParam(forwardings));
1012	strNatForwardings = "";
1013	for (size_t i = 0; i < forwardings.size(); ++i)
1014	{
1015	bool fSkip = false;
1016	uint16_t port = 0;
1017	BSTR r = forwardings[i];
1018	Utf8Str utf = Utf8Str(r);
1019	Utf8Str strName;
1020	Utf8Str strProto;
1021	Utf8Str strHostPort;
1022	Utf8Str strHostIP;
1023	Utf8Str strGuestPort;
1024	Utf8Str strGuestIP;
1025	size_t pos, ppos;
1026	pos = ppos = 0;
1027	#define ITERATE_TO_NEXT_TERM(res, str, pos, ppos) \
1028	do { \
1029	pos = str.find(",", ppos); \
1030	if (pos == Utf8Str::npos) \
1031	{ \
1032	Log(( #res " extracting from %s is failed\n", str.c_str())); \
1033	fSkip = true; \
1034	} \
1035	res = str.substr(ppos, pos - ppos); \
1036	Log2((#res " %s pos:%d, ppos:%d\n", res.c_str(), pos, ppos)); \
1037	ppos = pos + 1; \
1038	} while (0)
1039	ITERATE_TO_NEXT_TERM(strName, utf, pos, ppos);
1040	if (fSkip) continue;
1041	ITERATE_TO_NEXT_TERM(strProto, utf, pos, ppos);
1042	if (fSkip) continue;
1043	ITERATE_TO_NEXT_TERM(strHostIP, utf, pos, ppos);
1044	if (fSkip) continue;
1045	ITERATE_TO_NEXT_TERM(strHostPort, utf, pos, ppos);
1046	if (fSkip) continue;
1047	ITERATE_TO_NEXT_TERM(strGuestIP, utf, pos, ppos);
1048	if (fSkip) continue;
1049	strGuestPort = utf.substr(ppos, utf.length() - ppos);
1050	#undef ITERATE_TO_NEXT_TERM
1051	switch (strProto.toUInt32())
1052	{
1053	case NATProtocol_TCP:
1054	strProto = "tcp";
1055	break;
1056	case NATProtocol_UDP:
1057	strProto = "udp";
1058	break;
1059	default:
1060	strProto = "unk";
1061	break;
1062	}
1063	if (details == VMINFO_MACHINEREADABLE)
1064	{
1065	strNatForwardings = Utf8StrFmt("%sForwarding(%d)=\"%s,%s,%s,%s,%s,%s\"\n",
1066	strNatForwardings.c_str(), i, strName.c_str(), strProto.c_str(),
1067	strHostIP.c_str(), strHostPort.c_str(),
1068	strGuestIP.c_str(), strGuestPort.c_str());
1069	}
1070	else
1071	{
1072	strNatForwardings = Utf8StrFmt("%sNIC %d Rule(%d): name = %s, protocol = %s,"
1073	" host ip = %s, host port = %s, guest ip = %s, guest port = %s\n",
1074	strNatForwardings.c_str(), currentNIC + 1, i, strName.c_str(), strProto.c_str(),
1075	strHostIP.c_str(), strHostPort.c_str(),
1076	strGuestIP.c_str(), strGuestPort.c_str());
1077	}
1078	}
1079	ULONG mtu = 0;
1080	ULONG sockSnd = 0;
1081	ULONG sockRcv = 0;
1082	ULONG tcpSnd = 0;
1083	ULONG tcpRcv = 0;
1084	engine->GetNetworkSettings(&mtu, &sockSnd, &sockRcv, &tcpSnd, &tcpRcv);
1085
1086	/** @todo r=klaus dnsproxy etc needs to be dumped, too */
1087	if (details == VMINFO_MACHINEREADABLE)
1088	{
1089	RTPrintf("natnet%d=\"%ls\"\n", currentNIC + 1, strNetwork.length() ? strNetwork.raw(): Bstr("nat").raw());
1090	strAttachment = "nat";
1091	strNatSettings = Utf8StrFmt("mtu=\"%d\"\nsockSnd=\"%d\"\nsockRcv=\"%d\"\ntcpWndSnd=\"%d\"\ntcpWndRcv=\"%d\"\n",
1092	mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64, tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64);
1093	}
1094	else
1095	{
1096	strAttachment = "NAT";
1097	strNatSettings = Utf8StrFmt("NIC %d Settings: MTU: %d, Socket (send: %d, receive: %d), TCP Window (send:%d, receive: %d)\n",
1098	currentNIC + 1, mtu, sockSnd ? sockSnd : 64, sockRcv ? sockRcv : 64, tcpSnd ? tcpSnd : 64, tcpRcv ? tcpRcv : 64);
1099	}
1100	break;
1101	}
1102
1103	case NetworkAttachmentType_Bridged:
1104	{
1105	Bstr strBridgeAdp;
1106	nic->COMGETTER(BridgedInterface)(strBridgeAdp.asOutParam());
1107	if (details == VMINFO_MACHINEREADABLE)
1108	{
1109	RTPrintf("bridgeadapter%d=\"%ls\"\n", currentNIC + 1, strBridgeAdp.raw());
1110	strAttachment = "bridged";
1111	}
1112	else
1113	strAttachment = Utf8StrFmt("Bridged Interface '%ls'", strBridgeAdp.raw());
1114	break;
1115	}
1116
1117	case NetworkAttachmentType_Internal:
1118	{
1119	Bstr strNetwork;
1120	nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam());
1121	if (details == VMINFO_MACHINEREADABLE)
1122	{
1123	RTPrintf("intnet%d=\"%ls\"\n", currentNIC + 1, strNetwork.raw());
1124	strAttachment = "intnet";
1125	}
1126	else
1127	strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).c_str());
1128	break;
1129	}
1130
1131	case NetworkAttachmentType_HostOnly:
1132	{
1133	Bstr strHostonlyAdp;
1134	nic->COMGETTER(HostOnlyInterface)(strHostonlyAdp.asOutParam());
1135	if (details == VMINFO_MACHINEREADABLE)
1136	{
1137	RTPrintf("hostonlyadapter%d=\"%ls\"\n", currentNIC + 1, strHostonlyAdp.raw());
1138	strAttachment = "hostonly";
1139	}
1140	else
1141	strAttachment = Utf8StrFmt("Host-only Interface '%ls'", strHostonlyAdp.raw());
1142	break;
1143	}
1144
1145	case NetworkAttachmentType_Generic:
1146	{
1147	Bstr strGenericDriver;
1148	nic->COMGETTER(GenericDriver)(strGenericDriver.asOutParam());
1149	if (details == VMINFO_MACHINEREADABLE)
1150	{
1151	RTPrintf("generic%d=\"%ls\"\n", currentNIC + 1, strGenericDriver.raw());
1152	strAttachment = "Generic";
1153	}
1154	else
1155	{
1156	strAttachment = Utf8StrFmt("Generic '%ls'", strGenericDriver.raw());
1157
1158	// show the generic properties
1159	com::SafeArray<BSTR> aProperties;
1160	com::SafeArray<BSTR> aValues;
1161	rc = nic->GetProperties(NULL,
1162	ComSafeArrayAsOutParam(aProperties),
1163	ComSafeArrayAsOutParam(aValues));
1164	if (SUCCEEDED(rc))
1165	{
1166	strAttachment += " { ";
1167	for (unsigned i = 0; i < aProperties.size(); ++i)
1168	strAttachment += Utf8StrFmt(!i ? "%ls='%ls'" : ", %ls='%ls'",
1169	aProperties[i], aValues[i]);
1170	strAttachment += " }";
1171	}
1172	}
1173	break;
1174	}
1175
1176	case NetworkAttachmentType_NATNetwork:
1177	{
1178	Bstr strNetwork;
1179	nic->COMGETTER(NATNetwork)(strNetwork.asOutParam());
1180	if (details == VMINFO_MACHINEREADABLE)
1181	{
1182	RTPrintf("nat-network%d=\"%ls\"\n", currentNIC + 1, strNetwork.raw());
1183	strAttachment = "natnetwork";
1184	}
1185	else
1186	strAttachment = Utf8StrFmt("NAT Network '%s'", Utf8Str(strNetwork).c_str());
1187	break;
1188	}
1189
1190	default:
1191	strAttachment = "unknown";
1192	break;
1193	}
1194
1195	/* cable connected */
1196	BOOL fConnected;
1197	nic->COMGETTER(CableConnected)(&fConnected);
1198
1199	/* promisc policy */
1200	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1201	CHECK_ERROR2_RET(nic, COMGETTER(PromiscModePolicy)(&enmPromiscModePolicy), hrcCheck);
1202	const char *pszPromiscuousGuestPolicy;
1203	switch (enmPromiscModePolicy)
1204	{
1205	case NetworkAdapterPromiscModePolicy_Deny: pszPromiscuousGuestPolicy = "deny"; break;
1206	case NetworkAdapterPromiscModePolicy_AllowNetwork: pszPromiscuousGuestPolicy = "allow-vms"; break;
1207	case NetworkAdapterPromiscModePolicy_AllowAll: pszPromiscuousGuestPolicy = "allow-all"; break;
1208	default: AssertFailedReturn(E_INVALIDARG);
1209	}
1210
1211	/* trace stuff */
1212	BOOL fTraceEnabled;
1213	nic->COMGETTER(TraceEnabled)(&fTraceEnabled);
1214	Bstr traceFile;
1215	nic->COMGETTER(TraceFile)(traceFile.asOutParam());
1216
1217	/* NIC type */
1218	NetworkAdapterType_T NICType;
1219	nic->COMGETTER(AdapterType)(&NICType);
1220	const char *pszNICType;
1221	switch (NICType)
1222	{
1223	case NetworkAdapterType_Am79C970A: pszNICType = "Am79C970A"; break;
1224	case NetworkAdapterType_Am79C973: pszNICType = "Am79C973"; break;
1225	#ifdef VBOX_WITH_E1000
1226	case NetworkAdapterType_I82540EM: pszNICType = "82540EM"; break;
1227	case NetworkAdapterType_I82543GC: pszNICType = "82543GC"; break;
1228	case NetworkAdapterType_I82545EM: pszNICType = "82545EM"; break;
1229	#endif
1230	#ifdef VBOX_WITH_VIRTIO
1231	case NetworkAdapterType_Virtio: pszNICType = "virtio"; break;
1232	#endif
1233	default: AssertFailed(); pszNICType = "unknown"; break;
1234	}
1235
1236	/* reported line speed */
1237	ULONG ulLineSpeed;
1238	nic->COMGETTER(LineSpeed)(&ulLineSpeed);
1239
1240	/* boot priority of the adapter */
1241	ULONG ulBootPriority;
1242	nic->COMGETTER(BootPriority)(&ulBootPriority);
1243
1244	/* bandwidth group */
1245	ComObjPtr<IBandwidthGroup> pBwGroup;
1246	Bstr strBwGroup;
1247	nic->COMGETTER(BandwidthGroup)(pBwGroup.asOutParam());
1248	if (!pBwGroup.isNull())
1249	pBwGroup->COMGETTER(Name)(strBwGroup.asOutParam());
1250
1251	if (details == VMINFO_MACHINEREADABLE)
1252	{
1253	RTPrintf("macaddress%d=\"%ls\"\n", currentNIC + 1, strMACAddress.raw());
1254	RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off");
1255	RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.c_str());
1256	RTPrintf("nictype%d=\"%s\"\n", currentNIC + 1, pszNICType);
1257	RTPrintf("nicspeed%d=\"%d\"\n", currentNIC + 1, ulLineSpeed);
1258	}
1259	else
1260	RTPrintf("NIC %u: MAC: %ls, Attachment: %s, Cable connected: %s, Trace: %s (file: %ls), Type: %s, Reported speed: %d Mbps, Boot priority: %d, Promisc Policy: %s, Bandwidth group: %ls\n",
1261	currentNIC + 1, strMACAddress.raw(), strAttachment.c_str(),
1262	fConnected ? "on" : "off",
1263	fTraceEnabled ? "on" : "off",
1264	traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
1265	pszNICType,
1266	ulLineSpeed / 1000,
1267	(int)ulBootPriority,
1268	pszPromiscuousGuestPolicy,
1269	strBwGroup.isEmpty() ? Bstr("none").raw() : strBwGroup.raw());
1270	if (strNatSettings.length())
1271	RTPrintf(strNatSettings.c_str());
1272	if (strNatForwardings.length())
1273	RTPrintf(strNatForwardings.c_str());
1274	}
1275	}
1276	}
1277
1278	/* Pointing device information */
1279	PointingHIDType_T aPointingHID;
1280	const char *pszHID = "Unknown";
1281	const char *pszMrHID = "unknown";
1282	machine->COMGETTER(PointingHIDType)(&aPointingHID);
1283	switch (aPointingHID)
1284	{
1285	case PointingHIDType_None:
1286	pszHID = "None";
1287	pszMrHID = "none";
1288	break;
1289	case PointingHIDType_PS2Mouse:
1290	pszHID = "PS/2 Mouse";
1291	pszMrHID = "ps2mouse";
1292	break;
1293	case PointingHIDType_USBMouse:
1294	pszHID = "USB Mouse";
1295	pszMrHID = "usbmouse";
1296	break;
1297	case PointingHIDType_USBTablet:
1298	pszHID = "USB Tablet";
1299	pszMrHID = "usbtablet";
1300	break;
1301	case PointingHIDType_ComboMouse:
1302	pszHID = "USB Tablet and PS/2 Mouse";
1303	pszMrHID = "combomouse";
1304	break;
1305	case PointingHIDType_USBMultiTouch:
1306	pszHID = "USB Multi-Touch";
1307	pszMrHID = "usbmultitouch";
1308	break;
1309	default:
1310	break;
1311	}
1312	if (details == VMINFO_MACHINEREADABLE)
1313	RTPrintf("hidpointing=\"%s\"\n", pszMrHID);
1314	else
1315	RTPrintf("Pointing Device: %s\n", pszHID);
1316
1317	/* Keyboard device information */
1318	KeyboardHIDType_T aKeyboardHID;
1319	machine->COMGETTER(KeyboardHIDType)(&aKeyboardHID);
1320	pszHID = "Unknown";
1321	pszMrHID = "unknown";
1322	switch (aKeyboardHID)
1323	{
1324	case KeyboardHIDType_None:
1325	pszHID = "None";
1326	pszMrHID = "none";
1327	break;
1328	case KeyboardHIDType_PS2Keyboard:
1329	pszHID = "PS/2 Keyboard";
1330	pszMrHID = "ps2kbd";
1331	break;
1332	case KeyboardHIDType_USBKeyboard:
1333	pszHID = "USB Keyboard";
1334	pszMrHID = "usbkbd";
1335	break;
1336	case KeyboardHIDType_ComboKeyboard:
1337	pszHID = "USB and PS/2 Keyboard";
1338	pszMrHID = "combokbd";
1339	break;
1340	default:
1341	break;
1342	}
1343	if (details == VMINFO_MACHINEREADABLE)
1344	RTPrintf("hidkeyboard=\"%s\"\n", pszMrHID);
1345	else
1346	RTPrintf("Keyboard Device: %s\n", pszHID);
1347
1348	ComPtr<ISystemProperties> sysProps;
1349	pVirtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam());
1350
1351	/* get the maximum amount of UARTs */
1352	ULONG maxUARTs = 0;
1353	sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
1354	for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
1355	{
1356	ComPtr<ISerialPort> uart;
1357	rc = machine->GetSerialPort(currentUART, uart.asOutParam());
1358	if (SUCCEEDED(rc) && uart)
1359	{
1360	/* show the config of this UART */
1361	BOOL fEnabled;
1362	uart->COMGETTER(Enabled)(&fEnabled);
1363	if (!fEnabled)
1364	{
1365	if (details == VMINFO_MACHINEREADABLE)
1366	RTPrintf("uart%d=\"off\"\n", currentUART + 1);
1367	else
1368	RTPrintf("UART %d: disabled\n", currentUART + 1);
1369	}
1370	else
1371	{
1372	ULONG ulIRQ, ulIOBase;
1373	PortMode_T HostMode;
1374	Bstr path;
1375	BOOL fServer;
1376	uart->COMGETTER(IRQ)(&ulIRQ);
1377	uart->COMGETTER(IOBase)(&ulIOBase);
1378	uart->COMGETTER(Path)(path.asOutParam());
1379	uart->COMGETTER(Server)(&fServer);
1380	uart->COMGETTER(HostMode)(&HostMode);
1381
1382	if (details == VMINFO_MACHINEREADABLE)
1383	RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,
1384	ulIOBase, ulIRQ);
1385	else
1386	RTPrintf("UART %d: I/O base: %#06x, IRQ: %d",
1387	currentUART + 1, ulIOBase, ulIRQ);
1388	switch (HostMode)
1389	{
1390	default:
1391	case PortMode_Disconnected:
1392	if (details == VMINFO_MACHINEREADABLE)
1393	RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
1394	else
1395	RTPrintf(", disconnected\n");
1396	break;
1397	case PortMode_RawFile:
1398	if (details == VMINFO_MACHINEREADABLE)
1399	RTPrintf("uartmode%d=\"%ls\"\n", currentUART + 1,
1400	path.raw());
1401	else
1402	RTPrintf(", attached to raw file '%ls'\n",
1403	path.raw());
1404	break;
1405	case PortMode_HostPipe:
1406	if (details == VMINFO_MACHINEREADABLE)
1407	RTPrintf("uartmode%d=\"%s,%ls\"\n", currentUART + 1,
1408	fServer ? "server" : "client", path.raw());
1409	else
1410	RTPrintf(", attached to pipe (%s) '%ls'\n",
1411	fServer ? "server" : "client", path.raw());
1412	break;
1413	case PortMode_HostDevice:
1414	if (details == VMINFO_MACHINEREADABLE)
1415	RTPrintf("uartmode%d=\"%ls\"\n", currentUART + 1,
1416	path.raw());
1417	else
1418	RTPrintf(", attached to device '%ls'\n", path.raw());
1419	break;
1420	}
1421	}
1422	}
1423	}
1424
1425	/* get the maximum amount of LPTs */
1426	ULONG maxLPTs = 0;
1427	sysProps->COMGETTER(ParallelPortCount)(&maxLPTs);
1428	for (ULONG currentLPT = 0; currentLPT < maxLPTs; currentLPT++)
1429	{
1430	ComPtr<IParallelPort> lpt;
1431	rc = machine->GetParallelPort(currentLPT, lpt.asOutParam());
1432	if (SUCCEEDED(rc) && lpt)
1433	{
1434	/* show the config of this LPT */
1435	BOOL fEnabled;
1436	lpt->COMGETTER(Enabled)(&fEnabled);
1437	if (!fEnabled)
1438	{
1439	if (details == VMINFO_MACHINEREADABLE)
1440	RTPrintf("lpt%d=\"off\"\n", currentLPT + 1);
1441	else
1442	RTPrintf("LPT %d: disabled\n", currentLPT + 1);
1443	}
1444	else
1445	{
1446	ULONG ulIRQ, ulIOBase;
1447	Bstr path;
1448	lpt->COMGETTER(IRQ)(&ulIRQ);
1449	lpt->COMGETTER(IOBase)(&ulIOBase);
1450	lpt->COMGETTER(Path)(path.asOutParam());
1451
1452	if (details == VMINFO_MACHINEREADABLE)
1453	RTPrintf("lpt%d=\"%#06x,%d\"\n", currentLPT + 1,
1454	ulIOBase, ulIRQ);
1455	else
1456	RTPrintf("LPT %d: I/O base: %#06x, IRQ: %d",
1457	currentLPT + 1, ulIOBase, ulIRQ);
1458	if (details == VMINFO_MACHINEREADABLE)
1459	RTPrintf("lptmode%d=\"%ls\"\n", currentLPT + 1,
1460	path.raw());
1461	else
1462	RTPrintf(", attached to device '%ls'\n", path.raw());
1463	}
1464	}
1465	}
1466
1467	ComPtr<IAudioAdapter> AudioAdapter;
1468	rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
1469	if (SUCCEEDED(rc))
1470	{
1471	const char *pszDrv = "Unknown";
1472	const char *pszCtrl = "Unknown";
1473	BOOL fEnabled;
1474	rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
1475	if (SUCCEEDED(rc) && fEnabled)
1476	{
1477	AudioDriverType_T enmDrvType;
1478	rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
1479	switch (enmDrvType)
1480	{
1481	case AudioDriverType_Null:
1482	if (details == VMINFO_MACHINEREADABLE)
1483	pszDrv = "null";
1484	else
1485	pszDrv = "Null";
1486	break;
1487	case AudioDriverType_WinMM:
1488	if (details == VMINFO_MACHINEREADABLE)
1489	pszDrv = "winmm";
1490	else
1491	pszDrv = "WINMM";
1492	break;
1493	case AudioDriverType_DirectSound:
1494	if (details == VMINFO_MACHINEREADABLE)
1495	pszDrv = "dsound";
1496	else
1497	pszDrv = "DSOUND";
1498	break;
1499	case AudioDriverType_OSS:
1500	if (details == VMINFO_MACHINEREADABLE)
1501	pszDrv = "oss";
1502	else
1503	pszDrv = "OSS";
1504	break;
1505	case AudioDriverType_ALSA:
1506	if (details == VMINFO_MACHINEREADABLE)
1507	pszDrv = "alsa";
1508	else
1509	pszDrv = "ALSA";
1510	break;
1511	case AudioDriverType_Pulse:
1512	if (details == VMINFO_MACHINEREADABLE)
1513	pszDrv = "pulse";
1514	else
1515	pszDrv = "PulseAudio";
1516	break;
1517	case AudioDriverType_CoreAudio:
1518	if (details == VMINFO_MACHINEREADABLE)
1519	pszDrv = "coreaudio";
1520	else
1521	pszDrv = "CoreAudio";
1522	break;
1523	case AudioDriverType_SolAudio:
1524	if (details == VMINFO_MACHINEREADABLE)
1525	pszDrv = "solaudio";
1526	else
1527	pszDrv = "SolAudio";
1528	break;
1529	default:
1530	if (details == VMINFO_MACHINEREADABLE)
1531	pszDrv = "unknown";
1532	break;
1533	}
1534	AudioControllerType_T enmCtrlType;
1535	rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
1536	switch (enmCtrlType)
1537	{
1538	case AudioControllerType_AC97:
1539	if (details == VMINFO_MACHINEREADABLE)
1540	pszCtrl = "ac97";
1541	else
1542	pszCtrl = "AC97";
1543	break;
1544	case AudioControllerType_SB16:
1545	if (details == VMINFO_MACHINEREADABLE)
1546	pszCtrl = "sb16";
1547	else
1548	pszCtrl = "SB16";
1549	break;
1550	case AudioControllerType_HDA:
1551	if (details == VMINFO_MACHINEREADABLE)
1552	pszCtrl = "hda";
1553	else
1554	pszCtrl = "HDA";
1555	break;
1556	}
1557	}
1558	else
1559	fEnabled = FALSE;
1560	if (details == VMINFO_MACHINEREADABLE)
1561	{
1562	if (fEnabled)
1563	RTPrintf("audio=\"%s\"\n", pszDrv);
1564	else
1565	RTPrintf("audio=\"none\"\n");
1566	}
1567	else
1568	{
1569	RTPrintf("Audio: %s",
1570	fEnabled ? "enabled" : "disabled");
1571	if (fEnabled)
1572	RTPrintf(" (Driver: %s, Controller: %s)",
1573	pszDrv, pszCtrl);
1574	RTPrintf("\n");
1575	}
1576	}
1577
1578	/* Shared clipboard */
1579	{
1580	const char *psz = "Unknown";
1581	ClipboardMode_T enmMode;
1582	rc = machine->COMGETTER(ClipboardMode)(&enmMode);
1583	switch (enmMode)
1584	{
1585	case ClipboardMode_Disabled:
1586	if (details == VMINFO_MACHINEREADABLE)
1587	psz = "disabled";
1588	else
1589	psz = "disabled";
1590	break;
1591	case ClipboardMode_HostToGuest:
1592	if (details == VMINFO_MACHINEREADABLE)
1593	psz = "hosttoguest";
1594	else
1595	psz = "HostToGuest";
1596	break;
1597	case ClipboardMode_GuestToHost:
1598	if (details == VMINFO_MACHINEREADABLE)
1599	psz = "guesttohost";
1600	else
1601	psz = "GuestToHost";
1602	break;
1603	case ClipboardMode_Bidirectional:
1604	if (details == VMINFO_MACHINEREADABLE)
1605	psz = "bidirectional";
1606	else
1607	psz = "Bidirectional";
1608	break;
1609	default:
1610	if (details == VMINFO_MACHINEREADABLE)
1611	psz = "unknown";
1612	break;
1613	}
1614	if (details == VMINFO_MACHINEREADABLE)
1615	RTPrintf("clipboard=\"%s\"\n", psz);
1616	else
1617	RTPrintf("Clipboard Mode: %s\n", psz);
1618	}
1619
1620	/* Drag'n'drop */
1621	{
1622	const char *psz = "Unknown";
1623	DnDMode_T enmMode;
1624	rc = machine->COMGETTER(DnDMode)(&enmMode);
1625	switch (enmMode)
1626	{
1627	case DnDMode_Disabled:
1628	if (details == VMINFO_MACHINEREADABLE)
1629	psz = "disabled";
1630	else
1631	psz = "disabled";
1632	break;
1633	case DnDMode_HostToGuest:
1634	if (details == VMINFO_MACHINEREADABLE)
1635	psz = "hosttoguest";
1636	else
1637	psz = "HostToGuest";
1638	break;
1639	case DnDMode_GuestToHost:
1640	if (details == VMINFO_MACHINEREADABLE)
1641	psz = "guesttohost";
1642	else
1643	psz = "GuestToHost";
1644	break;
1645	case DnDMode_Bidirectional:
1646	if (details == VMINFO_MACHINEREADABLE)
1647	psz = "bidirectional";
1648	else
1649	psz = "Bidirectional";
1650	break;
1651	default:
1652	if (details == VMINFO_MACHINEREADABLE)
1653	psz = "unknown";
1654	break;
1655	}
1656	if (details == VMINFO_MACHINEREADABLE)
1657	RTPrintf("draganddrop=\"%s\"\n", psz);
1658	else
1659	RTPrintf("Drag'n'drop Mode: %s\n", psz);
1660	}
1661
1662	{
1663	SessionState_T sessState;
1664	rc = machine->COMGETTER(SessionState)(&sessState);
1665	if (SUCCEEDED(rc) && sessState != SessionState_Unlocked)
1666	{
1667	Bstr sessType;
1668	rc = machine->COMGETTER(SessionType)(sessType.asOutParam());
1669	if (SUCCEEDED(rc) && !sessType.isEmpty())
1670	{
1671	if (details == VMINFO_MACHINEREADABLE)
1672	RTPrintf("SessionType=\"%ls\"\n", sessType.raw());
1673	else
1674	RTPrintf("Session type: %ls\n", sessType.raw());
1675	}
1676	}
1677	}
1678
1679	if (pConsole)
1680	{
1681	do
1682	{
1683	ComPtr<IDisplay> display;
1684	rc = pConsole->COMGETTER(Display)(display.asOutParam());
1685	if (rc == E_ACCESSDENIED \|\| display.isNull())
1686	break; /* VM not powered up */
1687	if (FAILED(rc))
1688	{
1689	com::GlueHandleComError(pConsole, "COMGETTER(Display)(display.asOutParam())", rc, __FILE__, __LINE__);
1690	return rc;
1691	}
1692	ULONG xRes, yRes, bpp;
1693	LONG xOrigin, yOrigin;
1694	GuestMonitorStatus_T monitorStatus;
1695	rc = display->GetScreenResolution(0, &xRes, &yRes, &bpp, &xOrigin, &yOrigin, &monitorStatus);
1696	if (rc == E_ACCESSDENIED)
1697	break; /* VM not powered up */
1698	if (FAILED(rc))
1699	{
1700	com::ErrorInfo info(display, COM_IIDOF(IDisplay));
1701	GluePrintErrorInfo(info);
1702	return rc;
1703	}
1704	if (details == VMINFO_MACHINEREADABLE)
1705	RTPrintf("VideoMode=\"%d,%d,%d\"@%d,%d %d\n", xRes, yRes, bpp, xOrigin, yOrigin, monitorStatus);
1706	else
1707	{
1708	const char *pszMonitorStatus = "unknown status";
1709	switch (monitorStatus)
1710	{
1711	case GuestMonitorStatus_Enabled: pszMonitorStatus = "enabled"; break;
1712	case GuestMonitorStatus_Disabled: pszMonitorStatus = "disabled"; break;
1713	default: break;
1714	}
1715	RTPrintf("Video mode: %dx%dx%d at %d,%d %s\n", xRes, yRes, bpp, xOrigin, yOrigin, pszMonitorStatus);
1716	}
1717	}
1718	while (0);
1719	}
1720
1721	/*
1722	* Remote Desktop
1723	*/
1724	ComPtr<IVRDEServer> vrdeServer;
1725	rc = machine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
1726	if (SUCCEEDED(rc) && vrdeServer)
1727	{
1728	BOOL fEnabled = false;
1729	vrdeServer->COMGETTER(Enabled)(&fEnabled);
1730	if (fEnabled)
1731	{
1732	LONG currentPort = -1;
1733	Bstr ports;
1734	vrdeServer->GetVRDEProperty(Bstr("TCP/Ports").raw(), ports.asOutParam());
1735	Bstr address;
1736	vrdeServer->GetVRDEProperty(Bstr("TCP/Address").raw(), address.asOutParam());
1737	BOOL fMultiCon;
1738	vrdeServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
1739	BOOL fReuseCon;
1740	vrdeServer->COMGETTER(ReuseSingleConnection)(&fReuseCon);
1741	Bstr videoChannel;
1742	vrdeServer->GetVRDEProperty(Bstr("VideoChannel/Enabled").raw(), videoChannel.asOutParam());
1743	BOOL fVideoChannel = (videoChannel.compare(Bstr("true"), Bstr::CaseInsensitive)== 0)
1744	\|\| (videoChannel == "1");
1745	Bstr videoChannelQuality;
1746	vrdeServer->GetVRDEProperty(Bstr("VideoChannel/Quality").raw(), videoChannelQuality.asOutParam());
1747	AuthType_T authType;
1748	const char *strAuthType;
1749	vrdeServer->COMGETTER(AuthType)(&authType);
1750	switch (authType)
1751	{
1752	case AuthType_Null:
1753	strAuthType = "null";
1754	break;
1755	case AuthType_External:
1756	strAuthType = "external";
1757	break;
1758	case AuthType_Guest:
1759	strAuthType = "guest";
1760	break;
1761	default:
1762	strAuthType = "unknown";
1763	break;
1764	}
1765	if (pConsole)
1766	{
1767	ComPtr<IVRDEServerInfo> vrdeServerInfo;
1768	CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc);
1769	if (!vrdeServerInfo.isNull())
1770	{
1771	rc = vrdeServerInfo->COMGETTER(Port)(&currentPort);
1772	if (rc == E_ACCESSDENIED)
1773	{
1774	currentPort = -1; /* VM not powered up */
1775	}
1776	else if (FAILED(rc))
1777	{
1778	com::ErrorInfo info(vrdeServerInfo, COM_IIDOF(IVRDEServerInfo));
1779	GluePrintErrorInfo(info);
1780	return rc;
1781	}
1782	}
1783	}
1784	if (details == VMINFO_MACHINEREADABLE)
1785	{
1786	RTPrintf("vrde=\"on\"\n");
1787	RTPrintf("vrdeport=%d\n", currentPort);
1788	RTPrintf("vrdeports=\"%ls\"\n", ports.raw());
1789	RTPrintf("vrdeaddress=\"%ls\"\n", address.raw());
1790	RTPrintf("vrdeauthtype=\"%s\"\n", strAuthType);
1791	RTPrintf("vrdemulticon=\"%s\"\n", fMultiCon ? "on" : "off");
1792	RTPrintf("vrdereusecon=\"%s\"\n", fReuseCon ? "on" : "off");
1793	RTPrintf("vrdevideochannel=\"%s\"\n", fVideoChannel ? "on" : "off");
1794	if (fVideoChannel)
1795	RTPrintf("vrdevideochannelquality=\"%ls\"\n", videoChannelQuality.raw());
1796	}
1797	else
1798	{
1799	if (address.isEmpty())
1800	address = "0.0.0.0";
1801	RTPrintf("VRDE: enabled (Address %ls, Ports %ls, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n", address.raw(), ports.raw(), fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType);
1802	if (pConsole && currentPort != -1 && currentPort != 0)
1803	RTPrintf("VRDE port: %d\n", currentPort);
1804	if (fVideoChannel)
1805	RTPrintf("Video redirection: enabled (Quality %ls)\n", videoChannelQuality.raw());
1806	else
1807	RTPrintf("Video redirection: disabled\n");
1808	}
1809	com::SafeArray<BSTR> aProperties;
1810	if (SUCCEEDED(vrdeServer->COMGETTER(VRDEProperties)(ComSafeArrayAsOutParam(aProperties))))
1811	{
1812	unsigned i;
1813	for (i = 0; i < aProperties.size(); ++i)
1814	{
1815	Bstr value;
1816	vrdeServer->GetVRDEProperty(aProperties[i], value.asOutParam());
1817	if (details == VMINFO_MACHINEREADABLE)
1818	{
1819	if (value.isEmpty())
1820	RTPrintf("vrdeproperty[%ls]=<not set>\n", aProperties[i]);
1821	else
1822	RTPrintf("vrdeproperty[%ls]=\"%ls\"\n", aProperties[i], value.raw());
1823	}
1824	else
1825	{
1826	if (value.isEmpty())
1827	RTPrintf("VRDE property: %-10lS = <not set>\n", aProperties[i]);
1828	else
1829	RTPrintf("VRDE property: %-10lS = \"%ls\"\n", aProperties[i], value.raw());
1830	}
1831	}
1832	}
1833	}
1834	else
1835	{
1836	if (details == VMINFO_MACHINEREADABLE)
1837	RTPrintf("vrde=\"off\"\n");
1838	else
1839	RTPrintf("VRDE: disabled\n");
1840	}
1841	}
1842
1843	/*
1844	* USB.
1845	*/
1846	SafeIfaceArray<IUSBController> USBCtlColl;
1847	rc = machine->COMGETTER(USBControllers)(ComSafeArrayAsOutParam(USBCtlColl));
1848	if (SUCCEEDED(rc))
1849	{
1850	bool fOhciEnabled = false;
1851	bool fEhciEnabled = false;
1852	bool fXhciEnabled = false;
1853
1854	for (unsigned i = 0; i < USBCtlColl.size(); i++)
1855	{
1856	USBControllerType_T enmType;
1857
1858	rc = USBCtlColl[i]->COMGETTER(Type)(&enmType);
1859	if (SUCCEEDED(rc))
1860	{
1861	switch (enmType)
1862	{
1863	case USBControllerType_OHCI:
1864	fOhciEnabled = true;
1865	break;
1866	case USBControllerType_EHCI:
1867	fEhciEnabled = true;
1868	break;
1869	case USBControllerType_XHCI:
1870	fXhciEnabled = true;
1871	break;
1872	default:
1873	break;
1874	}
1875	}
1876	}
1877
1878	if (details == VMINFO_MACHINEREADABLE)
1879	RTPrintf("usb=\"%s\"\n", fOhciEnabled ? "on" : "off");
1880	else
1881	RTPrintf("USB: %s\n", fOhciEnabled ? "enabled" : "disabled");
1882
1883	if (details == VMINFO_MACHINEREADABLE)
1884	RTPrintf("ehci=\"%s\"\n", fEhciEnabled ? "on" : "off");
1885	else
1886	RTPrintf("EHCI: %s\n", fEhciEnabled ? "enabled" : "disabled");
1887
1888	if (details == VMINFO_MACHINEREADABLE)
1889	RTPrintf("xhci=\"%s\"\n", fXhciEnabled ? "on" : "off");
1890	else
1891	RTPrintf("XHCI: %s\n", fXhciEnabled ? "enabled" : "disabled");
1892	}
1893
1894	ComPtr<IUSBDeviceFilters> USBFlts;
1895	rc = machine->COMGETTER(USBDeviceFilters)(USBFlts.asOutParam());
1896	if (SUCCEEDED(rc))
1897	{
1898	SafeIfaceArray <IUSBDeviceFilter> Coll;
1899	rc = USBFlts->COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll));
1900	if (SUCCEEDED(rc))
1901	{
1902	if (details != VMINFO_MACHINEREADABLE)
1903	RTPrintf("\nUSB Device Filters:\n\n");
1904
1905	if (Coll.size() == 0)
1906	{
1907	if (details != VMINFO_MACHINEREADABLE)
1908	RTPrintf("<none>\n\n");
1909	}
1910	else
1911	{
1912	for (size_t index = 0; index < Coll.size(); ++index)
1913	{
1914	ComPtr<IUSBDeviceFilter> DevPtr = Coll[index];
1915
1916	/* Query info. */
1917
1918	if (details != VMINFO_MACHINEREADABLE)
1919	RTPrintf("Index: %zu\n", index);
1920
1921	BOOL bActive = FALSE;
1922	CHECK_ERROR_RET(DevPtr, COMGETTER(Active)(&bActive), rc);
1923	if (details == VMINFO_MACHINEREADABLE)
1924	RTPrintf("USBFilterActive%zu=\"%s\"\n", index + 1, bActive ? "on" : "off");
1925	else
1926	RTPrintf("Active: %s\n", bActive ? "yes" : "no");
1927
1928	Bstr bstr;
1929	CHECK_ERROR_RET(DevPtr, COMGETTER(Name)(bstr.asOutParam()), rc);
1930	if (details == VMINFO_MACHINEREADABLE)
1931	RTPrintf("USBFilterName%zu=\"%ls\"\n", index + 1, bstr.raw());
1932	else
1933	RTPrintf("Name: %ls\n", bstr.raw());
1934	CHECK_ERROR_RET(DevPtr, COMGETTER(VendorId)(bstr.asOutParam()), rc);
1935	if (details == VMINFO_MACHINEREADABLE)
1936	RTPrintf("USBFilterVendorId%zu=\"%ls\"\n", index + 1, bstr.raw());
1937	else
1938	RTPrintf("VendorId: %ls\n", bstr.raw());
1939	CHECK_ERROR_RET(DevPtr, COMGETTER(ProductId)(bstr.asOutParam()), rc);
1940	if (details == VMINFO_MACHINEREADABLE)
1941	RTPrintf("USBFilterProductId%zu=\"%ls\"\n", index + 1, bstr.raw());
1942	else
1943	RTPrintf("ProductId: %ls\n", bstr.raw());
1944	CHECK_ERROR_RET(DevPtr, COMGETTER(Revision)(bstr.asOutParam()), rc);
1945	if (details == VMINFO_MACHINEREADABLE)
1946	RTPrintf("USBFilterRevision%zu=\"%ls\"\n", index + 1, bstr.raw());
1947	else
1948	RTPrintf("Revision: %ls\n", bstr.raw());
1949	CHECK_ERROR_RET(DevPtr, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1950	if (details == VMINFO_MACHINEREADABLE)
1951	RTPrintf("USBFilterManufacturer%zu=\"%ls\"\n", index + 1, bstr.raw());
1952	else
1953	RTPrintf("Manufacturer: %ls\n", bstr.raw());
1954	CHECK_ERROR_RET(DevPtr, COMGETTER(Product)(bstr.asOutParam()), rc);
1955	if (details == VMINFO_MACHINEREADABLE)
1956	RTPrintf("USBFilterProduct%zu=\"%ls\"\n", index + 1, bstr.raw());
1957	else
1958	RTPrintf("Product: %ls\n", bstr.raw());
1959	CHECK_ERROR_RET(DevPtr, COMGETTER(Remote)(bstr.asOutParam()), rc);
1960	if (details == VMINFO_MACHINEREADABLE)
1961	RTPrintf("USBFilterRemote%zu=\"%ls\"\n", index + 1, bstr.raw());
1962	else
1963	RTPrintf("Remote: %ls\n", bstr.raw());
1964	CHECK_ERROR_RET(DevPtr, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1965	if (details == VMINFO_MACHINEREADABLE)
1966	RTPrintf("USBFilterSerialNumber%zu=\"%ls\"\n", index + 1, bstr.raw());
1967	else
1968	RTPrintf("Serial Number: %ls\n", bstr.raw());
1969	if (details != VMINFO_MACHINEREADABLE)
1970	{
1971	ULONG fMaskedIfs;
1972	CHECK_ERROR_RET(DevPtr, COMGETTER(MaskedInterfaces)(&fMaskedIfs), rc);
1973	if (fMaskedIfs)
1974	RTPrintf("Masked Interfaces: %#010x\n", fMaskedIfs);
1975	RTPrintf("\n");
1976	}
1977	}
1978	}
1979	}
1980
1981	if (pConsole)
1982	{
1983	/* scope */
1984	{
1985	if (details != VMINFO_MACHINEREADABLE)
1986	RTPrintf("Available remote USB devices:\n\n");
1987
1988	SafeIfaceArray <IHostUSBDevice> coll;
1989	CHECK_ERROR_RET(pConsole, COMGETTER(RemoteUSBDevices)(ComSafeArrayAsOutParam(coll)), rc);
1990
1991	if (coll.size() == 0)
1992	{
1993	if (details != VMINFO_MACHINEREADABLE)
1994	RTPrintf("<none>\n\n");
1995	}
1996	else
1997	{
1998	for (size_t index = 0; index < coll.size(); ++index)
1999	{
2000	ComPtr<IHostUSBDevice> dev = coll[index];
2001
2002	/* Query info. */
2003	Bstr id;
2004	CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), rc);
2005	USHORT usVendorId;
2006	CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), rc);
2007	USHORT usProductId;
2008	CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), rc);
2009	USHORT bcdRevision;
2010	CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc);
2011
2012	if (details == VMINFO_MACHINEREADABLE)
2013	RTPrintf("USBRemoteUUID%zu=\"%s\"\n"
2014	"USBRemoteVendorId%zu=\"%#06x\"\n"
2015	"USBRemoteProductId%zu=\"%#06x\"\n"
2016	"USBRemoteRevision%zu=\"%#04x%02x\"\n",
2017	index + 1, Utf8Str(id).c_str(),
2018	index + 1, usVendorId,
2019	index + 1, usProductId,
2020	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
2021	else
2022	RTPrintf("UUID: %s\n"
2023	"VendorId: %#06x (%04X)\n"
2024	"ProductId: %#06x (%04X)\n"
2025	"Revision: %u.%u (%02u%02u)\n",
2026	Utf8Str(id).c_str(),
2027	usVendorId, usVendorId, usProductId, usProductId,
2028	bcdRevision >> 8, bcdRevision & 0xff,
2029	bcdRevision >> 8, bcdRevision & 0xff);
2030
2031	/* optional stuff. */
2032	Bstr bstr;
2033	CHECK_ERROR_RET(dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
2034	if (!bstr.isEmpty())
2035	{
2036	if (details == VMINFO_MACHINEREADABLE)
2037	RTPrintf("USBRemoteManufacturer%zu=\"%ls\"\n", index + 1, bstr.raw());
2038	else
2039	RTPrintf("Manufacturer: %ls\n", bstr.raw());
2040	}
2041	CHECK_ERROR_RET(dev, COMGETTER(Product)(bstr.asOutParam()), rc);
2042	if (!bstr.isEmpty())
2043	{
2044	if (details == VMINFO_MACHINEREADABLE)
2045	RTPrintf("USBRemoteProduct%zu=\"%ls\"\n", index + 1, bstr.raw());
2046	else
2047	RTPrintf("Product: %ls\n", bstr.raw());
2048	}
2049	CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
2050	if (!bstr.isEmpty())
2051	{
2052	if (details == VMINFO_MACHINEREADABLE)
2053	RTPrintf("USBRemoteSerialNumber%zu=\"%ls\"\n", index + 1, bstr.raw());
2054	else
2055	RTPrintf("SerialNumber: %ls\n", bstr.raw());
2056	}
2057	CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), rc);
2058	if (!bstr.isEmpty())
2059	{
2060	if (details == VMINFO_MACHINEREADABLE)
2061	RTPrintf("USBRemoteAddress%zu=\"%ls\"\n", index + 1, bstr.raw());
2062	else
2063	RTPrintf("Address: %ls\n", bstr.raw());
2064	}
2065
2066	if (details != VMINFO_MACHINEREADABLE)
2067	RTPrintf("\n");
2068	}
2069	}
2070	}
2071
2072	/* scope */
2073	{
2074	if (details != VMINFO_MACHINEREADABLE)
2075	RTPrintf("Currently Attached USB Devices:\n\n");
2076
2077	SafeIfaceArray <IUSBDevice> coll;
2078	CHECK_ERROR_RET(pConsole, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(coll)), rc);
2079
2080	if (coll.size() == 0)
2081	{
2082	if (details != VMINFO_MACHINEREADABLE)
2083	RTPrintf("<none>\n\n");
2084	}
2085	else
2086	{
2087	for (size_t index = 0; index < coll.size(); ++index)
2088	{
2089	ComPtr<IUSBDevice> dev = coll[index];
2090
2091	/* Query info. */
2092	Bstr id;
2093	CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), rc);
2094	USHORT usVendorId;
2095	CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), rc);
2096	USHORT usProductId;
2097	CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), rc);
2098	USHORT bcdRevision;
2099	CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), rc);
2100
2101	if (details == VMINFO_MACHINEREADABLE)
2102	RTPrintf("USBAttachedUUID%zu=\"%s\"\n"
2103	"USBAttachedVendorId%zu=\"%#06x\"\n"
2104	"USBAttachedProductId%zu=\"%#06x\"\n"
2105	"USBAttachedRevision%zu=\"%#04x%02x\"\n",
2106	index + 1, Utf8Str(id).c_str(),
2107	index + 1, usVendorId,
2108	index + 1, usProductId,
2109	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
2110	else
2111	RTPrintf("UUID: %s\n"
2112	"VendorId: %#06x (%04X)\n"
2113	"ProductId: %#06x (%04X)\n"
2114	"Revision: %u.%u (%02u%02u)\n",
2115	Utf8Str(id).c_str(),
2116	usVendorId, usVendorId, usProductId, usProductId,
2117	bcdRevision >> 8, bcdRevision & 0xff,
2118	bcdRevision >> 8, bcdRevision & 0xff);
2119
2120	/* optional stuff. */
2121	Bstr bstr;
2122	CHECK_ERROR_RET(dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
2123	if (!bstr.isEmpty())
2124	{
2125	if (details == VMINFO_MACHINEREADABLE)
2126	RTPrintf("USBAttachedManufacturer%zu=\"%ls\"\n", index + 1, bstr.raw());
2127	else
2128	RTPrintf("Manufacturer: %ls\n", bstr.raw());
2129	}
2130	CHECK_ERROR_RET(dev, COMGETTER(Product)(bstr.asOutParam()), rc);
2131	if (!bstr.isEmpty())
2132	{
2133	if (details == VMINFO_MACHINEREADABLE)
2134	RTPrintf("USBAttachedProduct%zu=\"%ls\"\n", index + 1, bstr.raw());
2135	else
2136	RTPrintf("Product: %ls\n", bstr.raw());
2137	}
2138	CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
2139	if (!bstr.isEmpty())
2140	{
2141	if (details == VMINFO_MACHINEREADABLE)
2142	RTPrintf("USBAttachedSerialNumber%zu=\"%ls\"\n", index + 1, bstr.raw());
2143	else
2144	RTPrintf("SerialNumber: %ls\n", bstr.raw());
2145	}
2146	CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), rc);
2147	if (!bstr.isEmpty())
2148	{
2149	if (details == VMINFO_MACHINEREADABLE)
2150	RTPrintf("USBAttachedAddress%zu=\"%ls\"\n", index + 1, bstr.raw());
2151	else
2152	RTPrintf("Address: %ls\n", bstr.raw());
2153	}
2154
2155	if (details != VMINFO_MACHINEREADABLE)
2156	RTPrintf("\n");
2157	}
2158	}
2159	}
2160	}
2161	} /* USB */
2162
2163	#ifdef VBOX_WITH_PCI_PASSTHROUGH
2164	/* Host PCI passthrough devices */
2165	{
2166	SafeIfaceArray <IPCIDeviceAttachment> assignments;
2167	rc = machine->COMGETTER(PCIDeviceAssignments)(ComSafeArrayAsOutParam(assignments));
2168	if (SUCCEEDED(rc))
2169	{
2170	if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE))
2171	{
2172	RTPrintf("\nAttached physical PCI devices:\n\n");
2173	}
2174
2175	for (size_t index = 0; index < assignments.size(); ++index)
2176	{
2177	ComPtr<IPCIDeviceAttachment> Assignment = assignments[index];
2178	char szHostPCIAddress[32], szGuestPCIAddress[32];
2179	LONG iHostPCIAddress = -1, iGuestPCIAddress = -1;
2180	Bstr DevName;
2181
2182	Assignment->COMGETTER(Name)(DevName.asOutParam());
2183	Assignment->COMGETTER(HostAddress)(&iHostPCIAddress);
2184	Assignment->COMGETTER(GuestAddress)(&iGuestPCIAddress);
2185	PCIBusAddress().fromLong(iHostPCIAddress).format(szHostPCIAddress, sizeof(szHostPCIAddress));
2186	PCIBusAddress().fromLong(iGuestPCIAddress).format(szGuestPCIAddress, sizeof(szGuestPCIAddress));
2187
2188	if (details == VMINFO_MACHINEREADABLE)
2189	RTPrintf("AttachedHostPCI=%s,%s\n", szHostPCIAddress, szGuestPCIAddress);
2190	else
2191	RTPrintf(" Host device %ls at %s attached as %s\n", DevName.raw(), szHostPCIAddress, szGuestPCIAddress);
2192	}
2193
2194	if (assignments.size() > 0 && (details != VMINFO_MACHINEREADABLE))
2195	{
2196	RTPrintf("\n");
2197	}
2198	}
2199	}
2200	/* Host PCI passthrough devices */
2201	#endif
2202
2203	/*
2204	* Bandwidth groups
2205	*/
2206	if (details != VMINFO_MACHINEREADABLE)
2207	RTPrintf("Bandwidth groups: ");
2208	{
2209	ComPtr<IBandwidthControl> bwCtrl;
2210	CHECK_ERROR_RET(machine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()), rc);
2211
2212	rc = showBandwidthGroups(bwCtrl, details);
2213	}
2214
2215
2216	/*
2217	* Shared folders
2218	*/
2219	if (details != VMINFO_MACHINEREADABLE)
2220	RTPrintf("Shared folders: ");
2221	uint32_t numSharedFolders = 0;
2222	#if 0 // not yet implemented
2223	/* globally shared folders first */
2224	{
2225	SafeIfaceArray <ISharedFolder> sfColl;
2226	CHECK_ERROR_RET(pVirtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc);
2227	for (size_t i = 0; i < sfColl.size(); ++i)
2228	{
2229	ComPtr<ISharedFolder> sf = sfColl[i];
2230	Bstr name, hostPath;
2231	sf->COMGETTER(Name)(name.asOutParam());
2232	sf->COMGETTER(HostPath)(hostPath.asOutParam());
2233	RTPrintf("Name: '%ls', Host path: '%ls' (global mapping)\n", name.raw(), hostPath.raw());
2234	++numSharedFolders;
2235	}
2236	}
2237	#endif
2238	/* now VM mappings */
2239	{
2240	com::SafeIfaceArray <ISharedFolder> folders;
2241
2242	CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
2243
2244	for (size_t i = 0; i < folders.size(); ++i)
2245	{
2246	ComPtr<ISharedFolder> sf = folders[i];
2247
2248	Bstr name, hostPath;
2249	BOOL writable;
2250	sf->COMGETTER(Name)(name.asOutParam());
2251	sf->COMGETTER(HostPath)(hostPath.asOutParam());
2252	sf->COMGETTER(Writable)(&writable);
2253	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
2254	RTPrintf("\n\n");
2255	if (details == VMINFO_MACHINEREADABLE)
2256	{
2257	RTPrintf("SharedFolderNameMachineMapping%zu=\"%ls\"\n", i + 1,
2258	name.raw());
2259	RTPrintf("SharedFolderPathMachineMapping%zu=\"%ls\"\n", i + 1,
2260	hostPath.raw());
2261	}
2262	else
2263	RTPrintf("Name: '%ls', Host path: '%ls' (machine mapping), %s\n",
2264	name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
2265	++numSharedFolders;
2266	}
2267	}
2268	/* transient mappings */
2269	if (pConsole)
2270	{
2271	com::SafeIfaceArray <ISharedFolder> folders;
2272
2273	CHECK_ERROR_RET(pConsole, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
2274
2275	for (size_t i = 0; i < folders.size(); ++i)
2276	{
2277	ComPtr<ISharedFolder> sf = folders[i];
2278
2279	Bstr name, hostPath;
2280	sf->COMGETTER(Name)(name.asOutParam());
2281	sf->COMGETTER(HostPath)(hostPath.asOutParam());
2282	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
2283	RTPrintf("\n\n");
2284	if (details == VMINFO_MACHINEREADABLE)
2285	{
2286	RTPrintf("SharedFolderNameTransientMapping%zu=\"%ls\"\n", i + 1,
2287	name.raw());
2288	RTPrintf("SharedFolderPathTransientMapping%zu=\"%ls\"\n", i + 1,
2289	hostPath.raw());
2290	}
2291	else
2292	RTPrintf("Name: '%ls', Host path: '%ls' (transient mapping)\n", name.raw(), hostPath.raw());
2293	++numSharedFolders;
2294	}
2295	}
2296	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
2297	RTPrintf("<none>\n");
2298	if (details != VMINFO_MACHINEREADABLE)
2299	RTPrintf("\n");
2300
2301	if (pConsole)
2302	{
2303	/*
2304	* Live VRDE info.
2305	*/
2306	ComPtr<IVRDEServerInfo> vrdeServerInfo;
2307	CHECK_ERROR_RET(pConsole, COMGETTER(VRDEServerInfo)(vrdeServerInfo.asOutParam()), rc);
2308	BOOL Active = FALSE;
2309	ULONG NumberOfClients = 0;
2310	LONG64 BeginTime = 0;
2311	LONG64 EndTime = 0;
2312	LONG64 BytesSent = 0;
2313	LONG64 BytesSentTotal = 0;
2314	LONG64 BytesReceived = 0;
2315	LONG64 BytesReceivedTotal = 0;
2316	Bstr User;
2317	Bstr Domain;
2318	Bstr ClientName;
2319	Bstr ClientIP;
2320	ULONG ClientVersion = 0;
2321	ULONG EncryptionStyle = 0;
2322
2323	if (!vrdeServerInfo.isNull())
2324	{
2325	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Active)(&Active), rc);
2326	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(NumberOfClients)(&NumberOfClients), rc);
2327	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BeginTime)(&BeginTime), rc);
2328	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EndTime)(&EndTime), rc);
2329	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSent)(&BytesSent), rc);
2330	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesSentTotal)(&BytesSentTotal), rc);
2331	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceived)(&BytesReceived), rc);
2332	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(BytesReceivedTotal)(&BytesReceivedTotal), rc);
2333	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(User)(User.asOutParam()), rc);
2334	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(Domain)(Domain.asOutParam()), rc);
2335	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientName)(ClientName.asOutParam()), rc);
2336	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientIP)(ClientIP.asOutParam()), rc);
2337	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(ClientVersion)(&ClientVersion), rc);
2338	CHECK_ERROR_RET(vrdeServerInfo, COMGETTER(EncryptionStyle)(&EncryptionStyle), rc);
2339	}
2340
2341	if (details == VMINFO_MACHINEREADABLE)
2342	RTPrintf("VRDEActiveConnection=\"%s\"\n", Active ? "on": "off");
2343	else
2344	RTPrintf("VRDE Connection: %s\n", Active? "active": "not active");
2345
2346	if (details == VMINFO_MACHINEREADABLE)
2347	RTPrintf("VRDEClients=%d\n", NumberOfClients);
2348	else
2349	RTPrintf("Clients so far: %d\n", NumberOfClients);
2350
2351	if (NumberOfClients > 0)
2352	{
2353	char timestr[128];
2354
2355	if (Active)
2356	{
2357	makeTimeStr(timestr, sizeof(timestr), BeginTime);
2358	if (details == VMINFO_MACHINEREADABLE)
2359	RTPrintf("VRDEStartTime=\"%s\"\n", timestr);
2360	else
2361	RTPrintf("Start time: %s\n", timestr);
2362	}
2363	else
2364	{
2365	makeTimeStr(timestr, sizeof(timestr), BeginTime);
2366	if (details == VMINFO_MACHINEREADABLE)
2367	RTPrintf("VRDELastStartTime=\"%s\"\n", timestr);
2368	else
2369	RTPrintf("Last started: %s\n", timestr);
2370	makeTimeStr(timestr, sizeof(timestr), EndTime);
2371	if (details == VMINFO_MACHINEREADABLE)
2372	RTPrintf("VRDELastEndTime=\"%s\"\n", timestr);
2373	else
2374	RTPrintf("Last ended: %s\n", timestr);
2375	}
2376
2377	int64_t ThroughputSend = 0;
2378	int64_t ThroughputReceive = 0;
2379	if (EndTime != BeginTime)
2380	{
2381	ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime);
2382	ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
2383	}
2384
2385	if (details == VMINFO_MACHINEREADABLE)
2386	{
2387	RTPrintf("VRDEBytesSent=%lld\n", BytesSent);
2388	RTPrintf("VRDEThroughputSend=%lld\n", ThroughputSend);
2389	RTPrintf("VRDEBytesSentTotal=%lld\n", BytesSentTotal);
2390
2391	RTPrintf("VRDEBytesReceived=%lld\n", BytesReceived);
2392	RTPrintf("VRDEThroughputReceive=%lld\n", ThroughputReceive);
2393	RTPrintf("VRDEBytesReceivedTotal=%lld\n", BytesReceivedTotal);
2394	}
2395	else
2396	{
2397	RTPrintf("Sent: %lld Bytes\n", BytesSent);
2398	RTPrintf("Average speed: %lld B/s\n", ThroughputSend);
2399	RTPrintf("Sent total: %lld Bytes\n", BytesSentTotal);
2400
2401	RTPrintf("Received: %lld Bytes\n", BytesReceived);
2402	RTPrintf("Speed: %lld B/s\n", ThroughputReceive);
2403	RTPrintf("Received total: %lld Bytes\n", BytesReceivedTotal);
2404	}
2405
2406	if (Active)
2407	{
2408	if (details == VMINFO_MACHINEREADABLE)
2409	{
2410	RTPrintf("VRDEUserName=\"%ls\"\n", User.raw());
2411	RTPrintf("VRDEDomain=\"%ls\"\n", Domain.raw());
2412	RTPrintf("VRDEClientName=\"%ls\"\n", ClientName.raw());
2413	RTPrintf("VRDEClientIP=\"%ls\"\n", ClientIP.raw());
2414	RTPrintf("VRDEClientVersion=%d\n", ClientVersion);
2415	RTPrintf("VRDEEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
2416	}
2417	else
2418	{
2419	RTPrintf("User name: %ls\n", User.raw());
2420	RTPrintf("Domain: %ls\n", Domain.raw());
2421	RTPrintf("Client name: %ls\n", ClientName.raw());
2422	RTPrintf("Client IP: %ls\n", ClientIP.raw());
2423	RTPrintf("Client version: %d\n", ClientVersion);
2424	RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
2425	}
2426	}
2427	}
2428
2429	if (details != VMINFO_MACHINEREADABLE)
2430	RTPrintf("\n");
2431	}
2432
2433	{
2434	/* Video capture */
2435	BOOL bActive = FALSE;
2436	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureEnabled)(&bActive), rc);
2437	com::SafeArray<BOOL> screens;
2438	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureScreens)(ComSafeArrayAsOutParam(screens)), rc);
2439	ULONG Width;
2440	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureWidth)(&Width), rc);
2441	ULONG Height;
2442	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureHeight)(&Height), rc);
2443	ULONG Rate;
2444	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureRate)(&Rate), rc);
2445	ULONG Fps;
2446	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureFPS)(&Fps), rc);
2447	Bstr File;
2448	CHECK_ERROR_RET(machine, COMGETTER(VideoCaptureFile)(File.asOutParam()), rc);
2449	if (details == VMINFO_MACHINEREADABLE)
2450	{
2451	RTPrintf("vcpenabled=\"%s\"\n", bActive ? "on" : "off");
2452	RTPrintf("vcpscreens=");
2453	bool fComma = false;
2454	for (unsigned i = 0; i < screens.size(); i++)
2455	if (screens[i])
2456	{
2457	RTPrintf("%s%u", fComma ? "," : "", i);
2458	fComma = true;
2459	}
2460	RTPrintf("\n");
2461	RTPrintf("vcpfile=\"%ls\"\n", File.raw());
2462	RTPrintf("vcpwidth=%u\n", (unsigned)Width);
2463	RTPrintf("vcpheight=%u\n", (unsigned)Height);
2464	RTPrintf("vcprate=%u\n", (unsigned)Rate);
2465	RTPrintf("vcpfps=%u\n", (unsigned)Fps);
2466	}
2467	else
2468	{
2469	RTPrintf("Video capturing: %s\n", bActive ? "active" : "not active");
2470	RTPrintf("Capture screens: ");
2471	bool fComma = false;
2472	for (unsigned i = 0; i < screens.size(); i++)
2473	if (screens[i])
2474	{
2475	RTPrintf("%s%u", fComma ? "," : "", i);
2476	fComma = true;
2477	}
2478	RTPrintf("\n");
2479	RTPrintf("Capture file: %ls\n", File.raw());
2480	RTPrintf("Capture dimensions: %ux%u\n", Width, Height);
2481	RTPrintf("Capture rate: %u kbps\n", Rate);
2482	RTPrintf("Capture FPS: %u\n", Fps);
2483	RTPrintf("\n");
2484	}
2485	}
2486
2487	if ( details == VMINFO_STANDARD
2488	\|\| details == VMINFO_FULL
2489	\|\| details == VMINFO_MACHINEREADABLE)
2490	{
2491	Bstr description;
2492	machine->COMGETTER(Description)(description.asOutParam());
2493	if (!description.isEmpty())
2494	{
2495	if (details == VMINFO_MACHINEREADABLE)
2496	RTPrintf("description=\"%ls\"\n", description.raw());
2497	else
2498	RTPrintf("Description:\n%ls\n", description.raw());
2499	}
2500	}
2501
2502	if (details != VMINFO_MACHINEREADABLE)
2503	RTPrintf("Guest:\n\n");
2504
2505	ULONG guestVal;
2506	rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);
2507	if (SUCCEEDED(rc))
2508	{
2509	if (details == VMINFO_MACHINEREADABLE)
2510	RTPrintf("GuestMemoryBalloon=%d\n", guestVal);
2511	else
2512	RTPrintf("Configured memory balloon size: %d MB\n", guestVal);
2513	}
2514
2515	if (pConsole)
2516	{
2517	ComPtr<IGuest> guest;
2518	rc = pConsole->COMGETTER(Guest)(guest.asOutParam());
2519	if (SUCCEEDED(rc) && !guest.isNull())
2520	{
2521	Bstr guestString;
2522	rc = guest->COMGETTER(OSTypeId)(guestString.asOutParam());
2523	if ( SUCCEEDED(rc)
2524	&& !guestString.isEmpty())
2525	{
2526	if (details == VMINFO_MACHINEREADABLE)
2527	RTPrintf("GuestOSType=\"%ls\"\n", guestString.raw());
2528	else
2529	RTPrintf("OS type: %ls\n", guestString.raw());
2530	}
2531
2532	AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
2533	rc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
2534	if (SUCCEEDED(rc))
2535	{
2536	if (details == VMINFO_MACHINEREADABLE)
2537	RTPrintf("GuestAdditionsRunLevel=%u\n", guestRunLevel);
2538	else
2539	RTPrintf("Additions run level: %u\n", guestRunLevel);
2540	}
2541
2542	rc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
2543	if ( SUCCEEDED(rc)
2544	&& !guestString.isEmpty())
2545	{
2546	ULONG uRevision;
2547	rc = guest->COMGETTER(AdditionsRevision)(&uRevision);
2548	if (FAILED(rc))
2549	uRevision = 0;
2550
2551	if (details == VMINFO_MACHINEREADABLE)
2552	RTPrintf("GuestAdditionsVersion=\"%ls r%u\"\n", guestString.raw(), uRevision);
2553	else
2554	RTPrintf("Additions version: %ls r%u\n\n", guestString.raw(), uRevision);
2555	}
2556
2557	if (details != VMINFO_MACHINEREADABLE)
2558	RTPrintf("\nGuest Facilities:\n\n");
2559
2560	/* Print information about known Guest Additions facilities: */
2561	SafeIfaceArray <IAdditionsFacility> collFac;
2562	CHECK_ERROR_RET(guest, COMGETTER(Facilities)(ComSafeArrayAsOutParam(collFac)), rc);
2563	LONG64 lLastUpdatedMS;
2564	char szLastUpdated[32];
2565	AdditionsFacilityStatus_T curStatus;
2566	for (size_t index = 0; index < collFac.size(); ++index)
2567	{
2568	ComPtr<IAdditionsFacility> fac = collFac[index];
2569	if (fac)
2570	{
2571	CHECK_ERROR_RET(fac, COMGETTER(Name)(guestString.asOutParam()), rc);
2572	if (!guestString.isEmpty())
2573	{
2574	CHECK_ERROR_RET(fac, COMGETTER(Status)(&curStatus), rc);
2575	CHECK_ERROR_RET(fac, COMGETTER(LastUpdated)(&lLastUpdatedMS), rc);
2576	if (details == VMINFO_MACHINEREADABLE)
2577	RTPrintf("GuestAdditionsFacility_%ls=%u,%lld\n",
2578	guestString.raw(), curStatus, lLastUpdatedMS);
2579	else
2580	{
2581	makeTimeStr(szLastUpdated, sizeof(szLastUpdated), lLastUpdatedMS);
2582	RTPrintf("Facility \"%ls\": %s (last update: %s)\n",
2583	guestString.raw(), facilityStateToName(curStatus, false /* No short naming */), szLastUpdated);
2584	}
2585	}
2586	else
2587	AssertMsgFailed(("Facility with undefined name retrieved!\n"));
2588	}
2589	else
2590	AssertMsgFailed(("Invalid facility returned!\n"));
2591	}
2592	if (!collFac.size() && details != VMINFO_MACHINEREADABLE)
2593	RTPrintf("No active facilities.\n");
2594	}
2595	}
2596
2597	if (details != VMINFO_MACHINEREADABLE)
2598	RTPrintf("\n");
2599
2600	/*
2601	* snapshots
2602	*/
2603	ComPtr<ISnapshot> snapshot;
2604	rc = machine->FindSnapshot(Bstr().raw(), snapshot.asOutParam());
2605	if (SUCCEEDED(rc) && snapshot)
2606	{
2607	ComPtr<ISnapshot> currentSnapshot;
2608	rc = machine->COMGETTER(CurrentSnapshot)(currentSnapshot.asOutParam());
2609	if (SUCCEEDED(rc))
2610	{
2611	if (details != VMINFO_MACHINEREADABLE)
2612	RTPrintf("Snapshots:\n\n");
2613	showSnapshots(snapshot, currentSnapshot, details);
2614	}
2615	}
2616
2617	if (details != VMINFO_MACHINEREADABLE)
2618	RTPrintf("\n");
2619	return S_OK;
2620	}
2621
2622	#if defined(_MSC_VER)
2623	# pragma optimize("", on)
2624	#endif
2625
2626	static const RTGETOPTDEF g_aShowVMInfoOptions[] =
2627	{
2628	{ "--details", 'D', RTGETOPT_REQ_NOTHING },
2629	{ "-details", 'D', RTGETOPT_REQ_NOTHING }, // deprecated
2630	{ "--machinereadable", 'M', RTGETOPT_REQ_NOTHING },
2631	{ "-machinereadable", 'M', RTGETOPT_REQ_NOTHING }, // deprecated
2632	{ "--log", 'l', RTGETOPT_REQ_UINT32 },
2633	};
2634
2635	int handleShowVMInfo(HandlerArg *a)
2636	{
2637	HRESULT rc;
2638	const char *VMNameOrUuid = NULL;
2639	bool fLog = false;
2640	uint32_t uLogIdx = 0;
2641	bool fDetails = false;
2642	bool fMachinereadable = false;
2643
2644	int c;
2645	RTGETOPTUNION ValueUnion;
2646	RTGETOPTSTATE GetState;
2647	// start at 0 because main() has hacked both the argc and argv given to us
2648	RTGetOptInit(&GetState, a->argc, a->argv, g_aShowVMInfoOptions, RT_ELEMENTS(g_aShowVMInfoOptions),
2649	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
2650	while ((c = RTGetOpt(&GetState, &ValueUnion)))
2651	{
2652	switch (c)
2653	{
2654	case 'D': // --details
2655	fDetails = true;
2656	break;
2657
2658	case 'M': // --machinereadable
2659	fMachinereadable = true;
2660	break;
2661
2662	case 'l': // --log
2663	fLog = true;
2664	uLogIdx = ValueUnion.u32;
2665	break;
2666
2667	case VINF_GETOPT_NOT_OPTION:
2668	if (!VMNameOrUuid)
2669	VMNameOrUuid = ValueUnion.psz;
2670	else
2671	return errorSyntax(USAGE_SHOWVMINFO, "Invalid parameter '%s'", ValueUnion.psz);
2672	break;
2673
2674	default:
2675	if (c > 0)
2676	{
2677	if (RT_C_IS_PRINT(c))
2678	return errorSyntax(USAGE_SHOWVMINFO, "Invalid option -%c", c);
2679	else
2680	return errorSyntax(USAGE_SHOWVMINFO, "Invalid option case %i", c);
2681	}
2682	else if (c == VERR_GETOPT_UNKNOWN_OPTION)
2683	return errorSyntax(USAGE_SHOWVMINFO, "unknown option: %s\n", ValueUnion.psz);
2684	else if (ValueUnion.pDef)
2685	return errorSyntax(USAGE_SHOWVMINFO, "%s: %Rrs", ValueUnion.pDef->pszLong, c);
2686	else
2687	return errorSyntax(USAGE_SHOWVMINFO, "error: %Rrs", c);
2688	}
2689	}
2690
2691	/* check for required options */
2692	if (!VMNameOrUuid)
2693	return errorSyntax(USAGE_SHOWVMINFO, "VM name or UUID required");
2694
2695	/* try to find the given machine */
2696	ComPtr<IMachine> machine;
2697	CHECK_ERROR(a->virtualBox, FindMachine(Bstr(VMNameOrUuid).raw(),
2698	machine.asOutParam()));
2699	if (FAILED(rc))
2700	return 1;
2701
2702	/* Printing the log is exclusive. */
2703	if (fLog && (fMachinereadable \|\| fDetails))
2704	return errorSyntax(USAGE_SHOWVMINFO, "Option --log is exclusive");
2705
2706	if (fLog)
2707	{
2708	ULONG64 uOffset = 0;
2709	SafeArray<BYTE> aLogData;
2710	size_t cbLogData;
2711	while (true)
2712	{
2713	/* Reset the array */
2714	aLogData.setNull();
2715	/* Fetch a chunk of the log file */
2716	CHECK_ERROR_BREAK(machine, ReadLog(uLogIdx, uOffset, _1M,
2717	ComSafeArrayAsOutParam(aLogData)));
2718	cbLogData = aLogData.size();
2719	if (cbLogData == 0)
2720	break;
2721	/* aLogData has a platform dependent line ending, standardize on
2722	* Unix style, as RTStrmWrite does the LF -> CR/LF replacement on
2723	* Windows. Otherwise we end up with CR/CR/LF on Windows. */
2724	size_t cbLogDataPrint = cbLogData;
2725	for (BYTE s = aLogData.raw(), d = s;
2726	s - aLogData.raw() < (ssize_t)cbLogData;
2727	s++, d++)
2728	{
2729	if (*s == '\r')
2730	{
2731	/* skip over CR, adjust destination */
2732	d--;
2733	cbLogDataPrint--;
2734	}
2735	else if (s != d)
2736	d = s;
2737	}
2738	RTStrmWrite(g_pStdOut, aLogData.raw(), cbLogDataPrint);
2739	uOffset += cbLogData;
2740	}
2741	}
2742	else
2743	{
2744	/* 2nd option can be -details or -argdump */
2745	VMINFO_DETAILS details = VMINFO_NONE;
2746	if (fMachinereadable)
2747	details = VMINFO_MACHINEREADABLE;
2748	else if (fDetails)
2749	details = VMINFO_FULL;
2750	else
2751	details = VMINFO_STANDARD;
2752
2753	/* open an existing session for the VM */
2754	rc = machine->LockMachine(a->session, LockType_Shared);
2755	if (SUCCEEDED(rc))
2756	/* get the session machine */
2757	rc = a->session->COMGETTER(Machine)(machine.asOutParam());
2758
2759	rc = showVMInfo(a->virtualBox, machine, a->session, details);
2760
2761	a->session->UnlockMachine();
2762	}
2763
2764	return SUCCEEDED(rc) ? 0 : 1;
2765	}
2766
2767	#endif /* !VBOX_ONLY_DOCS */
2768	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp@ 55134

Download in other formats: