VBoxManageInfo.cpp@ 58445

Last change on this file since 58445 was 58437, checked in by vboxsync, 9 years ago
Main: Added paravirtdebug options.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 114.3 KB

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

Download in other formats: