VBoxManageInfo.cpp@ 85327

Last change on this file since 85327 was 85178, checked in by vboxsync, 4 years ago
OCI: (bugref:9469) help, showvminfo and 'experimental' label in UI.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 114.9 KB

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

Download in other formats: