VBoxManageInfo.cpp@ 17766

Last change on this file since 17766 was 17739, checked in by vboxsync, 16 years ago
Reduce scope of iteration indices. Convert some commented collection code to safe-array.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.4 KB

Line
1	/* $Id: VBoxManageInfo.cpp 17739 2009-03-12 12:38:15Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'showvminfo' command and helper routines.
4	*/
5
6	/*
7	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	#ifndef VBOX_ONLY_DOCS
23
24	/*******************************************************************************
25	* Header Files *
26	*******************************************************************************/
27	#include <VBox/com/com.h>
28	#include <VBox/com/string.h>
29	#include <VBox/com/Guid.h>
30	#include <VBox/com/array.h>
31	#include <VBox/com/ErrorInfo.h>
32	#include <VBox/com/errorprint2.h>
33
34	#include <VBox/com/VirtualBox.h>
35
36	#include <VBox/log.h>
37	#include <iprt/stream.h>
38	#include <iprt/time.h>
39	#include <iprt/string.h>
40
41	#include "VBoxManage.h"
42	using namespace com;
43
44
45	// funcs
46	///////////////////////////////////////////////////////////////////////////////
47
48	void showSnapshots(ComPtr<ISnapshot> rootSnapshot, VMINFO_DETAILS details, const Bstr &prefix /* = ""/, int level /= 0*/)
49	{
50	/* start with the root */
51	Bstr name;
52	Guid uuid;
53	rootSnapshot->COMGETTER(Name)(name.asOutParam());
54	rootSnapshot->COMGETTER(Id)(uuid.asOutParam());
55	if (details == VMINFO_MACHINEREADABLE)
56	{
57	/* print with hierarchical numbering */
58	RTPrintf("SnapshotName%lS=\"%lS\"\n", prefix.raw(), name.raw());
59	RTPrintf("SnapshotUUID%lS=\"%s\"\n", prefix.raw(), uuid.toString().raw());
60	}
61	else
62	{
63	/* print with indentation */
64	RTPrintf(" %lSName: %lS (UUID: %s)\n", prefix.raw(), name.raw(), uuid.toString().raw());
65	}
66
67	/* get the children */
68	SafeIfaceArray <ISnapshot> coll;
69	rootSnapshot->COMGETTER(Children)(ComSafeArrayAsOutParam(coll));
70	if (!coll.isNull())
71	{
72	for (size_t index = 0; index < coll.size(); ++index)
73	{
74	ComPtr<ISnapshot> snapshot = coll[index];
75	if (snapshot)
76	{
77	Bstr newPrefix;
78	if (details == VMINFO_MACHINEREADABLE)
79	newPrefix = Utf8StrFmt("%lS-%d", prefix.raw(), index + 1);
80	else
81	newPrefix = Utf8StrFmt("%lS ", prefix.raw());
82	/* recursive call */
83	showSnapshots(snapshot, details, newPrefix, level + 1);
84	}
85	}
86	}
87	}
88
89	static void makeTimeStr (char *s, int cb, int64_t millies)
90	{
91	RTTIME t;
92	RTTIMESPEC ts;
93
94	RTTimeSpecSetMilli(&ts, millies);
95
96	RTTimeExplode (&t, &ts);
97
98	RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
99	t.i32Year, t.u8Month, t.u8MonthDay,
100	t.u8Hour, t.u8Minute, t.u8Second);
101	}
102
103	/* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable
104	time. MSC 7.1/32 doesn't have quite as much trouble with it, but still
105	sufficient to qualify for this hack as well since this code isn't performance
106	critical and probably won't gain much from the extra optimizing in real life. */
107	#if defined(_MSC_VER)
108	# pragma optimize("g", off)
109	#endif
110
111	HRESULT showVMInfo (ComPtr<IVirtualBox> virtualBox,
112	ComPtr<IMachine> machine,
113	VMINFO_DETAILS details /= VMINFO_NONE/,
114	ComPtr<IConsole> console /= ComPtr <IConsole> ()/)
115	{
116	HRESULT rc;
117
118	/*
119	* The rules for output in -argdump format:
120	* 1) the key part (the [0-9a-zA-Z_]+ string before the '=' delimiter)
121	* is all lowercase for "VBoxManage modifyvm" parameters. Any
122	* other values printed are in CamelCase.
123	* 2) strings (anything non-decimal) are printed surrounded by
124	* double quotes '"'. If the strings themselves contain double
125	* quotes, these characters are escaped by '\'. Any '\' character
126	* in the original string is also escaped by '\'.
127	* 3) numbers (containing just [0-9\-]) are written out unchanged.
128	*/
129
130	/** @todo the quoting is not yet implemented! */
131
132	BOOL accessible = FALSE;
133	CHECK_ERROR (machine, COMGETTER(Accessible) (&accessible));
134	CheckComRCReturnRC (rc);
135
136	Guid uuid;
137	rc = machine->COMGETTER(Id) (uuid.asOutParam());
138
139	if (!accessible)
140	{
141	if (details == VMINFO_COMPACT)
142	RTPrintf("\"<inaccessible>\" {%s}\n", uuid.toString().raw());
143	else
144	{
145	if (details == VMINFO_MACHINEREADABLE)
146	RTPrintf("name=\"<inaccessible>\"\n");
147	else
148	RTPrintf ("Name: <inaccessible!>\n");
149	if (details == VMINFO_MACHINEREADABLE)
150	RTPrintf ("UUID=\"%s\"\n", uuid.toString().raw());
151	else
152	RTPrintf ("UUID: %s\n", uuid.toString().raw());
153	if (details != VMINFO_MACHINEREADABLE)
154	{
155	Bstr settingsFilePath;
156	rc = machine->COMGETTER(SettingsFilePath) (settingsFilePath.asOutParam());
157	RTPrintf ("Config file: %lS\n", settingsFilePath.raw());
158	ComPtr<IVirtualBoxErrorInfo> accessError;
159	rc = machine->COMGETTER(AccessError) (accessError.asOutParam());
160	RTPrintf ("Access error details:\n");
161	ErrorInfo ei (accessError);
162	GluePrintErrorInfo(ei);
163	RTPrintf ("\n");
164	}
165	}
166	return S_OK;
167	}
168
169	Bstr machineName;
170	rc = machine->COMGETTER(Name)(machineName.asOutParam());
171
172	if (details == VMINFO_COMPACT)
173	{
174	RTPrintf("\"%lS\" {%s}\n", machineName.raw(), uuid.toString().raw());
175	return S_OK;
176	}
177
178	if (details == VMINFO_MACHINEREADABLE)
179	RTPrintf("name=\"%lS\"\n", machineName.raw());
180	else
181	RTPrintf("Name: %lS\n", machineName.raw());
182
183	Bstr osTypeId;
184	rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());
185	ComPtr<IGuestOSType> osType;
186	rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());
187	Bstr osName;
188	rc = osType->COMGETTER(Description)(osName.asOutParam());
189	if (details == VMINFO_MACHINEREADABLE)
190	RTPrintf("ostype=\"%lS\"\n", osTypeId.raw());
191	else
192	RTPrintf("Guest OS: %lS\n", osName.raw());
193
194	if (details == VMINFO_MACHINEREADABLE)
195	RTPrintf("UUID=\"%s\"\n", uuid.toString().raw());
196	else
197	RTPrintf("UUID: %s\n", uuid.toString().raw());
198
199	Bstr settingsFilePath;
200	rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
201	if (details == VMINFO_MACHINEREADABLE)
202	RTPrintf("CfgFile=\"%lS\"\n", settingsFilePath.raw());
203	else
204	RTPrintf("Config file: %lS\n", settingsFilePath.raw());
205
206	ULONG memorySize;
207	rc = machine->COMGETTER(MemorySize)(&memorySize);
208	if (details == VMINFO_MACHINEREADABLE)
209	RTPrintf("memory=%u\n", memorySize);
210	else
211	RTPrintf("Memory size: %uMB\n", memorySize);
212
213	ULONG vramSize;
214	rc = machine->COMGETTER(VRAMSize)(&vramSize);
215	if (details == VMINFO_MACHINEREADABLE)
216	RTPrintf("vram=%u\n", vramSize);
217	else
218	RTPrintf("VRAM size: %uMB\n", vramSize);
219
220	ComPtr <IBIOSSettings> biosSettings;
221	machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
222
223	BIOSBootMenuMode_T bootMenuMode;
224	biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
225	const char *pszBootMenu = NULL;
226	switch (bootMenuMode)
227	{
228	case BIOSBootMenuMode_Disabled:
229	pszBootMenu = "disabled";
230	break;
231	case BIOSBootMenuMode_MenuOnly:
232	if (details == VMINFO_MACHINEREADABLE)
233	pszBootMenu = "menuonly";
234	else
235	pszBootMenu = "menu only";
236	break;
237	default:
238	if (details == VMINFO_MACHINEREADABLE)
239	pszBootMenu = "messageandmenu";
240	else
241	pszBootMenu = "message and menu";
242	}
243	if (details == VMINFO_MACHINEREADABLE)
244	RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);
245	else
246	RTPrintf("Boot menu mode: %s\n", pszBootMenu);
247
248	BOOL acpiEnabled;
249	biosSettings->COMGETTER(ACPIEnabled)(&acpiEnabled);
250	if (details == VMINFO_MACHINEREADABLE)
251	RTPrintf("acpi=\"%s\"\n", acpiEnabled ? "on" : "off");
252	else
253	RTPrintf("ACPI: %s\n", acpiEnabled ? "on" : "off");
254
255	BOOL ioapicEnabled;
256	biosSettings->COMGETTER(IOAPICEnabled)(&ioapicEnabled);
257	if (details == VMINFO_MACHINEREADABLE)
258	RTPrintf("ioapic=\"%s\"\n", ioapicEnabled ? "on" : "off");
259	else
260	RTPrintf("IOAPIC: %s\n", ioapicEnabled ? "on" : "off");
261
262	BOOL PAEEnabled;
263	machine->COMGETTER(PAEEnabled)(&PAEEnabled);
264	if (details == VMINFO_MACHINEREADABLE)
265	RTPrintf("pae=\"%s\"\n", PAEEnabled ? "on" : "off");
266	else
267	RTPrintf("PAE: %s\n", PAEEnabled ? "on" : "off");
268
269	LONG64 timeOffset;
270	biosSettings->COMGETTER(TimeOffset)(&timeOffset);
271	if (details == VMINFO_MACHINEREADABLE)
272	RTPrintf("biossystemtimeoffset=%lld\n", timeOffset);
273	else
274	RTPrintf("Time offset: %lld ms\n", timeOffset);
275
276	TSBool_T hwVirtExEnabled;
277	machine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled);
278	if (hwVirtExEnabled == TSBool_Default)
279	{
280	BOOL fHWVirtExEnabled;
281	ComPtr<ISystemProperties> systemProperties;
282	virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
283	systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled);
284	if (details == VMINFO_MACHINEREADABLE)
285	RTPrintf("hwvirtex=\"default\"\n");
286	else
287	RTPrintf("Hardw. virt.ext: Default (%s)\n", fHWVirtExEnabled ? "on" : "off");
288	}
289	else
290	{
291	if (details == VMINFO_MACHINEREADABLE)
292	RTPrintf("hwvirtex=\"%s\"\n", hwVirtExEnabled == TSBool_True ? "on" : "off");
293	else
294	RTPrintf("Hardw. virt.ext: %s\n", hwVirtExEnabled == TSBool_True ? "on" : "off");
295	}
296	BOOL HWVirtExNestedPagingEnabled;
297	machine->COMGETTER(HWVirtExNestedPagingEnabled)(&HWVirtExNestedPagingEnabled);
298	if (details == VMINFO_MACHINEREADABLE)
299	RTPrintf("nestedpaging=\"%s\"\n", HWVirtExNestedPagingEnabled ? "on" : "off");
300	else
301	RTPrintf("Nested Paging: %s\n", HWVirtExNestedPagingEnabled ? "on" : "off");
302
303	BOOL HWVirtExVPIDEnabled;
304	machine->COMGETTER(HWVirtExVPIDEnabled)(&HWVirtExVPIDEnabled);
305	if (details == VMINFO_MACHINEREADABLE)
306	RTPrintf("vtxvpid=\"%s\"\n", HWVirtExVPIDEnabled ? "on" : "off");
307	else
308	RTPrintf("VT-x VPID: %s\n", HWVirtExVPIDEnabled ? "on" : "off");
309
310	MachineState_T machineState;
311	const char *pszState = NULL;
312	rc = machine->COMGETTER(State)(&machineState);
313	switch (machineState)
314	{
315	case MachineState_PoweredOff:
316	if (details == VMINFO_MACHINEREADABLE)
317	pszState = "poweroff";
318	else
319	pszState = "powered off";
320	break;
321	case MachineState_Saved:
322	pszState = "saved";
323	break;
324	case MachineState_Aborted:
325	pszState = "aborted";
326	break;
327	case MachineState_Running:
328	pszState = "running";
329	break;
330	case MachineState_Paused:
331	pszState = "paused";
332	break;
333	case MachineState_Starting:
334	pszState = "starting";
335	break;
336	case MachineState_Stopping:
337	pszState = "stopping";
338	break;
339	case MachineState_Saving:
340	pszState = "saving";
341	break;
342	case MachineState_Restoring:
343	pszState = "restoring";
344	break;
345	default:
346	pszState = "unknown";
347	break;
348	}
349	LONG64 stateSince;
350	machine->COMGETTER(LastStateChange)(&stateSince);
351	RTTIMESPEC timeSpec;
352	RTTimeSpecSetMilli(&timeSpec, stateSince);
353	char pszTime[30] = {0};
354	RTTimeSpecToString(&timeSpec, pszTime, sizeof(pszTime));
355	if (details == VMINFO_MACHINEREADABLE)
356	{
357	RTPrintf("VMState=\"%s\"\n", pszState);
358	RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime);
359	}
360	else
361	RTPrintf("State: %s (since %s)\n", pszState, pszTime);
362
363	ULONG numMonitors;
364	machine->COMGETTER(MonitorCount)(&numMonitors);
365	if (details == VMINFO_MACHINEREADABLE)
366	RTPrintf("monitorcount=%d\n", numMonitors);
367	else
368	RTPrintf("Monitor count: %d\n", numMonitors);
369
370	BOOL accelerate3d;
371	machine->COMGETTER(Accelerate3DEnabled)(&accelerate3d);
372	if (details == VMINFO_MACHINEREADABLE)
373	RTPrintf("accelerate3d=\"%s\"\n", accelerate3d ? "on" : "off");
374	else
375	RTPrintf("3D Acceleration: %s\n", accelerate3d ? "on" : "off");
376
377	ComPtr<IFloppyDrive> floppyDrive;
378	rc = machine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
379	if (SUCCEEDED(rc) && floppyDrive)
380	{
381	BOOL fFloppyEnabled;
382	floppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
383	Utf8Str pszFloppy = "invalid";
384	if (fFloppyEnabled)
385	{
386	DriveState_T floppyState;
387	floppyDrive->COMGETTER(State)(&floppyState);
388	switch (floppyState)
389	{
390	case DriveState_ImageMounted:
391	{
392	ComPtr<IFloppyImage> floppyImage;
393	rc = floppyDrive->GetImage(floppyImage.asOutParam());
394	if (SUCCEEDED(rc) && floppyImage)
395	{
396	Bstr imagePath;
397	floppyImage->COMGETTER(Location)(imagePath.asOutParam());
398	Guid imageGuid;
399	floppyImage->COMGETTER(Id)(imageGuid.asOutParam());
400	if (details == VMINFO_MACHINEREADABLE)
401	{
402	RTPrintf("FloppyImageUUID=\"%s\"\n", imageGuid.toString().raw());
403	pszFloppy = Utf8StrFmt("%lS", imagePath.raw());
404	}
405	else
406	pszFloppy = Utf8StrFmt("%lS (UUID: %s)", imagePath.raw(), imageGuid.toString().raw());
407	}
408	break;
409	}
410
411	case DriveState_HostDriveCaptured:
412	{
413	ComPtr<IHostFloppyDrive> hostFloppyDrive;
414	rc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam());
415	if (SUCCEEDED(rc) && floppyDrive)
416	{
417	Bstr driveName;
418	hostFloppyDrive->COMGETTER(Name)(driveName.asOutParam());
419	if (details == VMINFO_MACHINEREADABLE)
420	pszFloppy = Utf8StrFmt("host:%lS", driveName.raw());
421	else
422	pszFloppy = Utf8StrFmt("Host drive %lS", driveName.raw());
423	}
424	break;
425	}
426
427	case DriveState_NotMounted:
428	{
429	pszFloppy = "empty";
430	break;
431	}
432	}
433	}
434	else
435	{
436	pszFloppy = "disabled";
437	}
438	if (details == VMINFO_MACHINEREADABLE)
439	RTPrintf("floppy=\"%s\"\n", pszFloppy.raw());
440	else
441	RTPrintf("Floppy: %s\n", pszFloppy.raw());
442	}
443
444	/*
445	* SATA.
446	*
447	* Contributed by: James Lucas
448	*/
449	#ifdef VBOX_WITH_AHCI
450	ComPtr<IStorageController> SataCtl;
451	bool fSataEnabled = false;
452
453	rc = machine->GetStorageControllerByName(Bstr("SATA"), SataCtl.asOutParam());
454	if (SUCCEEDED(rc))
455	fSataEnabled = true;
456
457	if (details == VMINFO_MACHINEREADABLE)
458	RTPrintf("sata=\"%s\"\n", fSataEnabled ? "on" : "off");
459	else
460	RTPrintf("SATA: %s\n", fSataEnabled ? "enabled" : "disabled");
461
462	/*
463	* SATA Hard disks
464	*/
465	if (fSataEnabled)
466	{
467	ComPtr<IHardDisk> hardDisk;
468	Bstr filePath;
469	ULONG cSataPorts;
470
471	SataCtl->COMGETTER(PortCount)(&cSataPorts);
472	for (ULONG i = 0; i < cSataPorts; ++ i)
473	{
474	rc = machine->GetHardDisk(Bstr("SATA"), i, 0, hardDisk.asOutParam());
475	if (SUCCEEDED(rc) && hardDisk)
476	{
477	hardDisk->COMGETTER(Location)(filePath.asOutParam());
478	hardDisk->COMGETTER(Id)(uuid.asOutParam());
479	if (details == VMINFO_MACHINEREADABLE)
480	{
481	RTPrintf("sataport%d=\"%lS\"\n", i, filePath.raw());
482	RTPrintf("SataPortImageUUID%d=\"%s\"\n", i, uuid.toString().raw());
483	}
484	else
485	RTPrintf("SATA %d: %lS (UUID: %s)\n", i, filePath.raw(), uuid.toString().raw());
486	}
487	else
488	{
489	if (details == VMINFO_MACHINEREADABLE)
490	RTPrintf("sata%d=\"none\"\n",i);
491	}
492	}
493	}
494	#endif
495
496	/*
497	* IDE Hard disks
498	*/
499	ComPtr<IStorageController> ideController;
500
501	rc = machine->GetStorageControllerByName(Bstr("IDE"), ideController.asOutParam());
502	if (SUCCEEDED(rc) && ideController)
503	{
504	StorageControllerType_T enmIdeController;
505	const char *pszIdeController = NULL;
506
507	rc = ideController->COMGETTER(ControllerType)(&enmIdeController);
508
509	switch (enmIdeController)
510	{
511	case StorageControllerType_PIIX3:
512	pszIdeController = "PIIX3";
513	break;
514	case StorageControllerType_PIIX4:
515	pszIdeController = "PIIX4";
516	break;
517	case StorageControllerType_ICH6:
518	pszIdeController = "ICH6";
519	break;
520	default:
521	pszIdeController = "unknown";
522	}
523	if (details == VMINFO_MACHINEREADABLE)
524	RTPrintf("idecontroller=\"%s\"\n", pszIdeController);
525	else
526	RTPrintf("IDE Controller: %s\n", pszIdeController);
527	}
528
529	ComPtr<IHardDisk> hardDisk;
530	Bstr filePath;
531	rc = machine->GetHardDisk(Bstr("IDE"), 0, 0, hardDisk.asOutParam());
532	if (SUCCEEDED(rc) && hardDisk)
533	{
534	hardDisk->COMGETTER(Location)(filePath.asOutParam());
535	hardDisk->COMGETTER(Id)(uuid.asOutParam());
536	if (details == VMINFO_MACHINEREADABLE)
537	{
538	RTPrintf("hda=\"%lS\"\n", filePath.raw());
539	RTPrintf("HdaImageUUID=\"%s\"\n", uuid.toString().raw());
540	}
541	else
542	RTPrintf("Primary master: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
543	}
544	else
545	{
546	if (details == VMINFO_MACHINEREADABLE)
547	RTPrintf("hda=\"none\"\n");
548	}
549	rc = machine->GetHardDisk(Bstr("IDE"), 0, 1, hardDisk.asOutParam());
550	if (SUCCEEDED(rc) && hardDisk)
551	{
552	hardDisk->COMGETTER(Location)(filePath.asOutParam());
553	hardDisk->COMGETTER(Id)(uuid.asOutParam());
554	if (details == VMINFO_MACHINEREADABLE)
555	{
556	RTPrintf("hdb=\"%lS\"\n", filePath.raw());
557	RTPrintf("HdbImageUUID=\"%s\"\n", uuid.toString().raw());
558	}
559	else
560	RTPrintf("Primary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
561	}
562	else
563	{
564	if (details == VMINFO_MACHINEREADABLE)
565	RTPrintf("hdb=\"none\"\n");
566	}
567	rc = machine->GetHardDisk(Bstr("IDE"), 1, 1, hardDisk.asOutParam());
568	if (SUCCEEDED(rc) && hardDisk)
569	{
570	hardDisk->COMGETTER(Location)(filePath.asOutParam());
571	hardDisk->COMGETTER(Id)(uuid.asOutParam());
572	if (details == VMINFO_MACHINEREADABLE)
573	{
574	RTPrintf("hdd=\"%lS\"\n", filePath.raw());
575	RTPrintf("HddImageUUID=\"%s\"\n", uuid.toString().raw());
576	}
577	else
578	RTPrintf("Secondary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
579	}
580	else
581	{
582	if (details == VMINFO_MACHINEREADABLE)
583	RTPrintf("hdd=\"none\"\n");
584	}
585	ComPtr<IDVDDrive> dvdDrive;
586	rc = machine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
587	if (SUCCEEDED(rc) && dvdDrive)
588	{
589	ComPtr<IDVDImage> dvdImage;
590	rc = dvdDrive->GetImage(dvdImage.asOutParam());
591	if (SUCCEEDED(rc) && dvdImage)
592	{
593	rc = dvdImage->COMGETTER(Location)(filePath.asOutParam());
594	if (SUCCEEDED(rc) && filePath)
595	{
596	rc = dvdImage->COMGETTER(Id)(uuid.asOutParam());
597	if (details == VMINFO_MACHINEREADABLE)
598	{
599	RTPrintf("dvd=\"%lS\"\n", filePath.raw());
600	RTPrintf("DvdImageUUID=\"%s\"\n", uuid.toString().raw());
601	}
602	else
603	RTPrintf("DVD: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
604	}
605	}
606	else
607	{
608	ComPtr<IHostDVDDrive> hostDVDDrive;
609	rc = dvdDrive->GetHostDrive(hostDVDDrive.asOutParam());
610	if (SUCCEEDED(rc) && hostDVDDrive)
611	{
612	Bstr name;
613	hostDVDDrive->COMGETTER(Name)(name.asOutParam());
614	if (details == VMINFO_MACHINEREADABLE)
615	RTPrintf("dvd=\"host:%lS\"\n", name.raw());
616	else
617	RTPrintf("DVD: Host drive %lS", name.raw());
618	}
619	else
620	{
621	if (details == VMINFO_MACHINEREADABLE)
622	RTPrintf("dvd=\"none\"\n");
623	else
624	RTPrintf("DVD: empty");
625	}
626	BOOL fPassthrough;
627	dvdDrive->COMGETTER(Passthrough)(&fPassthrough);
628	if (details == VMINFO_MACHINEREADABLE)
629	{
630	RTPrintf("dvdpassthrough=\"%s\"\n", fPassthrough ? "on" : "off");
631	}
632	else
633	{
634	if (fPassthrough)
635	RTPrintf(" (passthrough enabled)");
636	RTPrintf("\n");
637	}
638	}
639	}
640
641	/* get the maximum amount of NICS */
642	ComPtr<ISystemProperties> sysProps;
643	virtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam());
644	ULONG maxNICs = 0;
645	sysProps->COMGETTER(NetworkAdapterCount)(&maxNICs);
646	for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)
647	{
648	ComPtr<INetworkAdapter> nic;
649	rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
650	if (SUCCEEDED(rc) && nic)
651	{
652	BOOL fEnabled;
653	nic->COMGETTER(Enabled)(&fEnabled);
654	if (!fEnabled)
655	{
656	if (details == VMINFO_MACHINEREADABLE)
657	RTPrintf("nic%d=\"none\"\n", currentNIC + 1);
658	else
659	RTPrintf("NIC %d: disabled\n", currentNIC + 1);
660	}
661	else
662	{
663	Bstr strMACAddress;
664	nic->COMGETTER(MACAddress)(strMACAddress.asOutParam());
665	Utf8Str strAttachment;
666	NetworkAttachmentType_T attachment;
667	nic->COMGETTER(AttachmentType)(&attachment);
668	switch (attachment)
669	{
670	case NetworkAttachmentType_Null:
671	if (details == VMINFO_MACHINEREADABLE)
672	strAttachment = "null";
673	else
674	strAttachment = "none";
675	break;
676	case NetworkAttachmentType_NAT:
677	{
678	Bstr strNetwork;
679	nic->COMGETTER(NATNetwork)(strNetwork.asOutParam());
680	if (details == VMINFO_MACHINEREADABLE)
681	{
682	RTPrintf("natnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
683	strAttachment = "nat";
684	}
685	else if (!strNetwork.isEmpty())
686	strAttachment = Utf8StrFmt("NAT (%lS)", strNetwork.raw());
687	else
688	strAttachment = "NAT";
689	break;
690	}
691	case NetworkAttachmentType_Bridged:
692	{
693	Bstr strBridgeAdp;
694	nic->COMGETTER(HostInterface)(strBridgeAdp.asOutParam());
695	if (details == VMINFO_MACHINEREADABLE)
696	{
697	RTPrintf("bridgeadapter%d=\"%lS\"\n", currentNIC + 1, strBridgeAdp.raw());
698	strAttachment = "bridged";
699	}
700	else
701	strAttachment = Utf8StrFmt("Bridged Interface '%lS'", strBridgeAdp.raw());
702	break;
703	}
704	case NetworkAttachmentType_Internal:
705	{
706	Bstr strNetwork;
707	nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam());
708	if (details == VMINFO_MACHINEREADABLE)
709	{
710	RTPrintf("intnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
711	strAttachment = "intnet";
712	}
713	else
714	strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).raw());
715	break;
716	}
717	case NetworkAttachmentType_HostOnly:
718	{
719	#if (defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT))
720	Bstr strHostonlyAdp;
721	nic->COMGETTER(HostInterface)(strHostonlyAdp.asOutParam());
722	#endif
723	if (details == VMINFO_MACHINEREADABLE)
724	{
725	#if (defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT))
726	RTPrintf("hostonlyadapter%d=\"%lS\"\n", currentNIC + 1, strHostonlyAdp.raw());
727	#endif
728	strAttachment = "hostonly";
729	}
730	else
731	#if (defined(RT_OS_WINDOWS) && defined(VBOX_WITH_NETFLT))
732	strAttachment = Utf8StrFmt("Host-only Interface '%lS'", strHostonlyAdp.raw());
733	#else
734	strAttachment = "Host-only Network";
735	#endif
736	break;
737	}
738	default:
739	strAttachment = "unknown";
740	break;
741	}
742
743	/* cable connected */
744	BOOL fConnected;
745	nic->COMGETTER(CableConnected)(&fConnected);
746
747	/* trace stuff */
748	BOOL fTraceEnabled;
749	nic->COMGETTER(TraceEnabled)(&fTraceEnabled);
750	Bstr traceFile;
751	nic->COMGETTER(TraceFile)(traceFile.asOutParam());
752
753	/* NIC type */
754	Utf8Str strNICType;
755	NetworkAdapterType_T NICType;
756	nic->COMGETTER(AdapterType)(&NICType);
757	switch (NICType) {
758	case NetworkAdapterType_Am79C970A:
759	strNICType = "Am79C970A";
760	break;
761	case NetworkAdapterType_Am79C973:
762	strNICType = "Am79C973";
763	break;
764	#ifdef VBOX_WITH_E1000
765	case NetworkAdapterType_I82540EM:
766	strNICType = "82540EM";
767	break;
768	case NetworkAdapterType_I82543GC:
769	strNICType = "82543GC";
770	break;
771	#endif
772	default:
773	strNICType = "unknown";
774	break;
775	}
776
777	/* reported line speed */
778	ULONG ulLineSpeed;
779	nic->COMGETTER(LineSpeed)(&ulLineSpeed);
780
781	if (details == VMINFO_MACHINEREADABLE)
782	{
783	RTPrintf("macaddress%d=\"%lS\"\n", currentNIC + 1, strMACAddress.raw());
784	RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off");
785	RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.raw());
786	}
787	else
788	RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Cable connected: %s, Trace: %s (file: %lS), Type: %s, Reported speed: %d Mbps\n",
789	currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),
790	fConnected ? "on" : "off",
791	fTraceEnabled ? "on" : "off",
792	traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
793	strNICType.raw(),
794	ulLineSpeed / 1000);
795	}
796	}
797	}
798
799	/* get the maximum amount of UARTs */
800	ULONG maxUARTs = 0;
801	sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
802	for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
803	{
804	ComPtr<ISerialPort> uart;
805	rc = machine->GetSerialPort(currentUART, uart.asOutParam());
806	if (SUCCEEDED(rc) && uart)
807	{
808	BOOL fEnabled;
809	uart->COMGETTER(Enabled)(&fEnabled);
810	if (!fEnabled)
811	{
812	if (details == VMINFO_MACHINEREADABLE)
813	RTPrintf("uart%d=\"off\"\n", currentUART + 1);
814	else
815	RTPrintf("UART %d: disabled\n", currentUART + 1);
816	}
817	else
818	{
819	ULONG ulIRQ, ulIOBase;
820	PortMode_T HostMode;
821	Bstr path;
822	BOOL fServer;
823	uart->COMGETTER(IRQ)(&ulIRQ);
824	uart->COMGETTER(IOBase)(&ulIOBase);
825	uart->COMGETTER(Path)(path.asOutParam());
826	uart->COMGETTER(Server)(&fServer);
827	uart->COMGETTER(HostMode)(&HostMode);
828
829	if (details == VMINFO_MACHINEREADABLE)
830	RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,
831	ulIOBase, ulIRQ);
832	else
833	RTPrintf("UART %d: I/O base: 0x%04x, IRQ: %d",
834	currentUART + 1, ulIOBase, ulIRQ);
835	switch (HostMode)
836	{
837	default:
838	case PortMode_Disconnected:
839	if (details == VMINFO_MACHINEREADABLE)
840	RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
841	else
842	RTPrintf(", disconnected\n");
843	break;
844	case PortMode_HostPipe:
845	if (details == VMINFO_MACHINEREADABLE)
846	RTPrintf("uartmode%d=\"%s,%lS\"\n", currentUART + 1,
847	fServer ? "server" : "client", path.raw());
848	else
849	RTPrintf(", attached to pipe (%s) '%lS'\n",
850	fServer ? "server" : "client", path.raw());
851	break;
852	case PortMode_HostDevice:
853	if (details == VMINFO_MACHINEREADABLE)
854	RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
855	path.raw());
856	else
857	RTPrintf(", attached to device '%lS'\n", path.raw());
858	break;
859	}
860	}
861	}
862	}
863
864	ComPtr<IAudioAdapter> AudioAdapter;
865	rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
866	if (SUCCEEDED(rc))
867	{
868	const char *pszDrv = "Unknown";
869	const char *pszCtrl = "Unknown";
870	BOOL fEnabled;
871	rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
872	if (SUCCEEDED(rc) && fEnabled)
873	{
874	AudioDriverType_T enmDrvType;
875	rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
876	switch (enmDrvType)
877	{
878	case AudioDriverType_Null:
879	if (details == VMINFO_MACHINEREADABLE)
880	pszDrv = "null";
881	else
882	pszDrv = "Null";
883	break;
884	case AudioDriverType_WinMM:
885	if (details == VMINFO_MACHINEREADABLE)
886	pszDrv = "winmm";
887	else
888	pszDrv = "WINMM";
889	break;
890	case AudioDriverType_DirectSound:
891	if (details == VMINFO_MACHINEREADABLE)
892	pszDrv = "dsound";
893	else
894	pszDrv = "DSOUND";
895	break;
896	case AudioDriverType_OSS:
897	if (details == VMINFO_MACHINEREADABLE)
898	pszDrv = "oss";
899	else
900	pszDrv = "OSS";
901	break;
902	case AudioDriverType_ALSA:
903	if (details == VMINFO_MACHINEREADABLE)
904	pszDrv = "alsa";
905	else
906	pszDrv = "ALSA";
907	break;
908	case AudioDriverType_Pulse:
909	if (details == VMINFO_MACHINEREADABLE)
910	pszDrv = "pulse";
911	else
912	pszDrv = "PulseAudio";
913	break;
914	case AudioDriverType_CoreAudio:
915	if (details == VMINFO_MACHINEREADABLE)
916	pszDrv = "coreaudio";
917	else
918	pszDrv = "CoreAudio";
919	break;
920	case AudioDriverType_SolAudio:
921	if (details == VMINFO_MACHINEREADABLE)
922	pszDrv = "solaudio";
923	else
924	pszDrv = "SolAudio";
925	break;
926	default:
927	if (details == VMINFO_MACHINEREADABLE)
928	pszDrv = "unknown";
929	break;
930	}
931	AudioControllerType_T enmCtrlType;
932	rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
933	switch (enmCtrlType)
934	{
935	case AudioControllerType_AC97:
936	if (details == VMINFO_MACHINEREADABLE)
937	pszCtrl = "ac97";
938	else
939	pszCtrl = "AC97";
940	break;
941	case AudioControllerType_SB16:
942	if (details == VMINFO_MACHINEREADABLE)
943	pszCtrl = "sb16";
944	else
945	pszCtrl = "SB16";
946	break;
947	}
948	}
949	else
950	fEnabled = FALSE;
951	if (details == VMINFO_MACHINEREADABLE)
952	{
953	if (fEnabled)
954	RTPrintf("audio=\"%s\"\n", pszDrv);
955	else
956	RTPrintf("audio=\"none\"\n");
957	}
958	else
959	RTPrintf("Audio: %s (Driver: %s, Controller: %s)\n",
960	fEnabled ? "enabled" : "disabled", pszDrv, pszCtrl);
961	}
962
963	/* Shared clipboard */
964	{
965	const char *psz = "Unknown";
966	ClipboardMode_T enmMode;
967	rc = machine->COMGETTER(ClipboardMode)(&enmMode);
968	switch (enmMode)
969	{
970	case ClipboardMode_Disabled:
971	if (details == VMINFO_MACHINEREADABLE)
972	psz = "disabled";
973	else
974	psz = "disabled";
975	break;
976	case ClipboardMode_HostToGuest:
977	if (details == VMINFO_MACHINEREADABLE)
978	psz = "hosttoguest";
979	else
980	psz = "HostToGuest";
981	break;
982	case ClipboardMode_GuestToHost:
983	if (details == VMINFO_MACHINEREADABLE)
984	psz = "guesttohost";
985	else
986	psz = "GuestToHost";
987	break;
988	case ClipboardMode_Bidirectional:
989	if (details == VMINFO_MACHINEREADABLE)
990	psz = "bidirectional";
991	else
992	psz = "Bidirectional";
993	break;
994	default:
995	if (details == VMINFO_MACHINEREADABLE)
996	psz = "unknown";
997	break;
998	}
999	if (details == VMINFO_MACHINEREADABLE)
1000	RTPrintf("clipboard=\"%s\"\n", psz);
1001	else
1002	RTPrintf("Clipboard Mode: %s\n", psz);
1003	}
1004
1005	if (console)
1006	{
1007	ComPtr<IDisplay> display;
1008	CHECK_ERROR_RET(console, COMGETTER(Display)(display.asOutParam()), rc);
1009	do
1010	{
1011	ULONG xRes, yRes, bpp;
1012	rc = display->COMGETTER(Width)(&xRes);
1013	if (rc == E_ACCESSDENIED)
1014	break; /* VM not powered up */
1015	if (FAILED(rc))
1016	{
1017	com::ErrorInfo info (display);
1018	GluePrintErrorInfo(info);
1019	return rc;
1020	}
1021	rc = display->COMGETTER(Height)(&yRes);
1022	if (rc == E_ACCESSDENIED)
1023	break; /* VM not powered up */
1024	if (FAILED(rc))
1025	{
1026	com::ErrorInfo info (display);
1027	GluePrintErrorInfo(info);
1028	return rc;
1029	}
1030	rc = display->COMGETTER(BitsPerPixel)(&bpp);
1031	if (rc == E_ACCESSDENIED)
1032	break; /* VM not powered up */
1033	if (FAILED(rc))
1034	{
1035	com::ErrorInfo info (display);
1036	GluePrintErrorInfo(info);
1037	return rc;
1038	}
1039	if (details == VMINFO_MACHINEREADABLE)
1040	RTPrintf("VideoMode=\"%d,%d,%d\"\n", xRes, yRes, bpp);
1041	else
1042	RTPrintf("Video mode: %dx%dx%d\n", xRes, yRes, bpp);
1043	}
1044	while (0);
1045	}
1046
1047	/*
1048	* VRDP
1049	*/
1050	ComPtr<IVRDPServer> vrdpServer;
1051	rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1052	if (SUCCEEDED(rc) && vrdpServer)
1053	{
1054	BOOL fEnabled = false;
1055	vrdpServer->COMGETTER(Enabled)(&fEnabled);
1056	if (fEnabled)
1057	{
1058	ULONG port;
1059	vrdpServer->COMGETTER(Port)(&port);
1060	Bstr address;
1061	vrdpServer->COMGETTER(NetAddress)(address.asOutParam());
1062	BOOL fMultiCon;
1063	vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
1064	BOOL fReuseCon;
1065	vrdpServer->COMGETTER(ReuseSingleConnection)(&fReuseCon);
1066	VRDPAuthType_T vrdpAuthType;
1067	const char *strAuthType;
1068	vrdpServer->COMGETTER(AuthType)(&vrdpAuthType);
1069	switch (vrdpAuthType)
1070	{
1071	case VRDPAuthType_Null:
1072	strAuthType = "null";
1073	break;
1074	case VRDPAuthType_External:
1075	strAuthType = "external";
1076	break;
1077	case VRDPAuthType_Guest:
1078	strAuthType = "guest";
1079	break;
1080	default:
1081	strAuthType = "unknown";
1082	break;
1083	}
1084	if (details == VMINFO_MACHINEREADABLE)
1085	{
1086	RTPrintf("vrdp=\"on\"\n");
1087	RTPrintf("vrdpport=%d\n", port);
1088	RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());
1089	RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);
1090	RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");
1091	RTPrintf("vrdpreusecon=\"%s\"\n", fReuseCon ? "on" : "off");
1092	}
1093	else
1094	{
1095	if (address.isEmpty())
1096	address = "0.0.0.0";
1097	RTPrintf("VRDP: enabled (Address %lS, Port %d, MultiConn: %s, ReuseSingleConn: %s, Authentication type: %s)\n", address.raw(), port, fMultiCon ? "on" : "off", fReuseCon ? "on" : "off", strAuthType);
1098	}
1099	}
1100	else
1101	{
1102	if (details == VMINFO_MACHINEREADABLE)
1103	RTPrintf("vrdp=\"off\"\n");
1104	else
1105	RTPrintf("VRDP: disabled\n");
1106	}
1107	}
1108
1109	/*
1110	* USB.
1111	*/
1112	ComPtr<IUSBController> USBCtl;
1113	rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());
1114	if (SUCCEEDED(rc))
1115	{
1116	BOOL fEnabled;
1117	rc = USBCtl->COMGETTER(Enabled)(&fEnabled);
1118	if (FAILED(rc))
1119	fEnabled = false;
1120	if (details == VMINFO_MACHINEREADABLE)
1121	RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");
1122	else
1123	RTPrintf("USB: %s\n", fEnabled ? "enabled" : "disabled");
1124
1125	if (details != VMINFO_MACHINEREADABLE)
1126	RTPrintf("\nUSB Device Filters:\n\n");
1127
1128	SafeIfaceArray <IUSBDeviceFilter> Coll;
1129	CHECK_ERROR_RET (USBCtl, COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll)), rc);
1130
1131	if (Coll.size() == 0)
1132	{
1133	if (details != VMINFO_MACHINEREADABLE)
1134	RTPrintf("<none>\n\n");
1135	}
1136	else
1137	{
1138	for (size_t index = 0; index < Coll.size(); ++index)
1139	{
1140	ComPtr<IUSBDeviceFilter> DevPtr = Coll[index];
1141
1142	/* Query info. */
1143
1144	if (details != VMINFO_MACHINEREADABLE)
1145	RTPrintf("Index: %zu\n", index);
1146
1147	BOOL bActive = FALSE;
1148	CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
1149	if (details == VMINFO_MACHINEREADABLE)
1150	RTPrintf("USBFilterActive%zu=\"%s\"\n", index + 1, bActive ? "on" : "off");
1151	else
1152	RTPrintf("Active: %s\n", bActive ? "yes" : "no");
1153
1154	Bstr bstr;
1155	CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);
1156	if (details == VMINFO_MACHINEREADABLE)
1157	RTPrintf("USBFilterName%zu=\"%lS\"\n", index + 1, bstr.raw());
1158	else
1159	RTPrintf("Name: %lS\n", bstr.raw());
1160	CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);
1161	if (details == VMINFO_MACHINEREADABLE)
1162	RTPrintf("USBFilterVendorId%zu=\"%lS\"\n", index + 1, bstr.raw());
1163	else
1164	RTPrintf("VendorId: %lS\n", bstr.raw());
1165	CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);
1166	if (details == VMINFO_MACHINEREADABLE)
1167	RTPrintf("USBFilterProductId%zu=\"%lS\"\n", index + 1, bstr.raw());
1168	else
1169	RTPrintf("ProductId: %lS\n", bstr.raw());
1170	CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);
1171	if (details == VMINFO_MACHINEREADABLE)
1172	RTPrintf("USBFilterRevision%zu=\"%lS\"\n", index + 1, bstr.raw());
1173	else
1174	RTPrintf("Revision: %lS\n", bstr.raw());
1175	CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);
1176	if (details == VMINFO_MACHINEREADABLE)
1177	RTPrintf("USBFilterManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1178	else
1179	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1180	CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);
1181	if (details == VMINFO_MACHINEREADABLE)
1182	RTPrintf("USBFilterProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1183	else
1184	RTPrintf("Product: %lS\n", bstr.raw());
1185	CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);
1186	if (details == VMINFO_MACHINEREADABLE)
1187	RTPrintf("USBFilterRemote%zu=\"%lS\"\n", index + 1, bstr.raw());
1188	else
1189	RTPrintf("Remote: %lS\n", bstr.raw());
1190	CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);
1191	if (details == VMINFO_MACHINEREADABLE)
1192	RTPrintf("USBFilterSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1193	else
1194	RTPrintf("Serial Number: %lS\n", bstr.raw());
1195	if (details != VMINFO_MACHINEREADABLE)
1196	{
1197	ULONG fMaskedIfs;
1198	CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);
1199	if (fMaskedIfs)
1200	RTPrintf("Masked Interfaces: 0x%08x\n", fMaskedIfs);
1201	RTPrintf("\n");
1202	}
1203	}
1204	}
1205
1206	if (console)
1207	{
1208	/* scope */
1209	{
1210	if (details != VMINFO_MACHINEREADABLE)
1211	RTPrintf("Available remote USB devices:\n\n");
1212
1213	SafeIfaceArray <IHostUSBDevice> coll;
1214	CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1215
1216	if (coll.size() == 0)
1217	{
1218	if (details != VMINFO_MACHINEREADABLE)
1219	RTPrintf("<none>\n\n");
1220	}
1221	else
1222	{
1223	for (size_t index = 0; index < coll.size(); ++index)
1224	{
1225	ComPtr <IHostUSBDevice> dev = coll[index];
1226
1227	/* Query info. */
1228	Guid id;
1229	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1230	USHORT usVendorId;
1231	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1232	USHORT usProductId;
1233	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1234	USHORT bcdRevision;
1235	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1236
1237	if (details == VMINFO_MACHINEREADABLE)
1238	RTPrintf("USBRemoteUUID%zu=\"%S\"\n"
1239	"USBRemoteVendorId%zu=\"%#06x\"\n"
1240	"USBRemoteProductId%zu=\"%#06x\"\n"
1241	"USBRemoteRevision%zu=\"%#04x%02x\"\n",
1242	index + 1, id.toString().raw(),
1243	index + 1, usVendorId,
1244	index + 1, usProductId,
1245	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1246	else
1247	RTPrintf("UUID: %S\n"
1248	"VendorId: 0x%04x (%04X)\n"
1249	"ProductId: 0x%04x (%04X)\n"
1250	"Revision: %u.%u (%02u%02u)\n",
1251	id.toString().raw(),
1252	usVendorId, usVendorId, usProductId, usProductId,
1253	bcdRevision >> 8, bcdRevision & 0xff,
1254	bcdRevision >> 8, bcdRevision & 0xff);
1255
1256	/* optional stuff. */
1257	Bstr bstr;
1258	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1259	if (!bstr.isEmpty())
1260	{
1261	if (details == VMINFO_MACHINEREADABLE)
1262	RTPrintf("USBRemoteManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1263	else
1264	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1265	}
1266	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1267	if (!bstr.isEmpty())
1268	{
1269	if (details == VMINFO_MACHINEREADABLE)
1270	RTPrintf("USBRemoteProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1271	else
1272	RTPrintf("Product: %lS\n", bstr.raw());
1273	}
1274	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1275	if (!bstr.isEmpty())
1276	{
1277	if (details == VMINFO_MACHINEREADABLE)
1278	RTPrintf("USBRemoteSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1279	else
1280	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1281	}
1282	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1283	if (!bstr.isEmpty())
1284	{
1285	if (details == VMINFO_MACHINEREADABLE)
1286	RTPrintf("USBRemoteAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1287	else
1288	RTPrintf("Address: %lS\n", bstr.raw());
1289	}
1290
1291	if (details != VMINFO_MACHINEREADABLE)
1292	RTPrintf("\n");
1293	}
1294	}
1295	}
1296
1297	/* scope */
1298	{
1299	if (details != VMINFO_MACHINEREADABLE)
1300	RTPrintf ("Currently Attached USB Devices:\n\n");
1301
1302	SafeIfaceArray <IUSBDevice> coll;
1303	CHECK_ERROR_RET (console, COMGETTER(USBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1304
1305	if (coll.size() == 0)
1306	{
1307	if (details != VMINFO_MACHINEREADABLE)
1308	RTPrintf("<none>\n\n");
1309	}
1310	else
1311	{
1312	for (size_t index = 0; index < coll.size(); ++index)
1313	{
1314	ComPtr <IUSBDevice> dev = coll[index];
1315
1316	/* Query info. */
1317	Guid id;
1318	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1319	USHORT usVendorId;
1320	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1321	USHORT usProductId;
1322	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1323	USHORT bcdRevision;
1324	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1325
1326	if (details == VMINFO_MACHINEREADABLE)
1327	RTPrintf("USBAttachedUUID%zu=\"%S\"\n"
1328	"USBAttachedVendorId%zu=\"%#06x\"\n"
1329	"USBAttachedProductId%zu=\"%#06x\"\n"
1330	"USBAttachedRevision%zu=\"%#04x%02x\"\n",
1331	index + 1, id.toString().raw(),
1332	index + 1, usVendorId,
1333	index + 1, usProductId,
1334	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1335	else
1336	RTPrintf("UUID: %S\n"
1337	"VendorId: 0x%04x (%04X)\n"
1338	"ProductId: 0x%04x (%04X)\n"
1339	"Revision: %u.%u (%02u%02u)\n",
1340	id.toString().raw(),
1341	usVendorId, usVendorId, usProductId, usProductId,
1342	bcdRevision >> 8, bcdRevision & 0xff,
1343	bcdRevision >> 8, bcdRevision & 0xff);
1344
1345	/* optional stuff. */
1346	Bstr bstr;
1347	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1348	if (!bstr.isEmpty())
1349	{
1350	if (details == VMINFO_MACHINEREADABLE)
1351	RTPrintf("USBAttachedManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1352	else
1353	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1354	}
1355	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1356	if (!bstr.isEmpty())
1357	{
1358	if (details == VMINFO_MACHINEREADABLE)
1359	RTPrintf("USBAttachedProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1360	else
1361	RTPrintf("Product: %lS\n", bstr.raw());
1362	}
1363	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1364	if (!bstr.isEmpty())
1365	{
1366	if (details == VMINFO_MACHINEREADABLE)
1367	RTPrintf("USBAttachedSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1368	else
1369	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1370	}
1371	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1372	if (!bstr.isEmpty())
1373	{
1374	if (details == VMINFO_MACHINEREADABLE)
1375	RTPrintf("USBAttachedAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1376	else
1377	RTPrintf("Address: %lS\n", bstr.raw());
1378	}
1379
1380	if (details != VMINFO_MACHINEREADABLE)
1381	RTPrintf("\n");
1382	}
1383	}
1384	}
1385	}
1386	} /* USB */
1387
1388	/*
1389	* Shared folders
1390	*/
1391	if (details != VMINFO_MACHINEREADABLE)
1392	RTPrintf("Shared folders: ");
1393	uint32_t numSharedFolders = 0;
1394	#if 0 // not yet implemented
1395	/* globally shared folders first */
1396	{
1397	SafeIfaceArray <ISharedFolder> sfColl;
1398	CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc);
1399	for (size_t i = 0; i < sfColl.size(); ++i)
1400	{
1401	ComPtr<ISharedFolder> sf = sfColl[i];
1402	Bstr name, hostPath;
1403	sf->COMGETTER(Name)(name.asOutParam());
1404	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1405	RTPrintf("Name: '%lS', Host path: '%lS' (global mapping)\n", name.raw(), hostPath.raw());
1406	++numSharedFolders;
1407	}
1408	}
1409	#endif
1410	/* now VM mappings */
1411	{
1412	com::SafeIfaceArray <ISharedFolder> folders;
1413
1414	CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1415	ULONG index = 0;
1416
1417	for (size_t i = 0; i < folders.size(); ++i)
1418	{
1419	ComPtr <ISharedFolder> sf = folders[i];
1420
1421	Bstr name, hostPath;
1422	BOOL writable;
1423	sf->COMGETTER(Name)(name.asOutParam());
1424	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1425	sf->COMGETTER(Writable)(&writable);
1426	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1427	RTPrintf("\n\n");
1428	if (details == VMINFO_MACHINEREADABLE)
1429	{
1430	RTPrintf("SharedFolderNameMachineMapping%d=\"%lS\"\n", index + 1,
1431	name.raw());
1432	RTPrintf("SharedFolderPathMachineMapping%d=\"%lS\"\n", index + 1,
1433	hostPath.raw());
1434	}
1435	else
1436	RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
1437	name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
1438	++numSharedFolders;
1439	}
1440	}
1441	/* transient mappings */
1442	if (console)
1443	{
1444	com::SafeIfaceArray <ISharedFolder> folders;
1445
1446	CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1447	ULONG index = 0;
1448
1449	for (size_t i = 0; i < folders.size(); ++i)
1450	{
1451	ComPtr <ISharedFolder> sf = folders[i];
1452
1453	Bstr name, hostPath;
1454	sf->COMGETTER(Name)(name.asOutParam());
1455	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1456	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1457	RTPrintf("\n\n");
1458	if (details == VMINFO_MACHINEREADABLE)
1459	{
1460	RTPrintf("SharedFolderNameTransientMapping%d=\"%lS\"\n", index + 1,
1461	name.raw());
1462	RTPrintf("SharedFolderPathTransientMapping%d=\"%lS\"\n", index + 1,
1463	hostPath.raw());
1464	}
1465	else
1466	RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());
1467	++numSharedFolders;
1468	}
1469	}
1470	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1471	RTPrintf("<none>\n");
1472	if (details != VMINFO_MACHINEREADABLE)
1473	RTPrintf("\n");
1474
1475	if (console)
1476	{
1477	/*
1478	* Live VRDP info.
1479	*/
1480	ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
1481	CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
1482	BOOL Active;
1483	ULONG NumberOfClients;
1484	LONG64 BeginTime;
1485	LONG64 EndTime;
1486	ULONG64 BytesSent;
1487	ULONG64 BytesSentTotal;
1488	ULONG64 BytesReceived;
1489	ULONG64 BytesReceivedTotal;
1490	Bstr User;
1491	Bstr Domain;
1492	Bstr ClientName;
1493	Bstr ClientIP;
1494	ULONG ClientVersion;
1495	ULONG EncryptionStyle;
1496
1497	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active) (&Active), rc);
1498	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients) (&NumberOfClients), rc);
1499	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime) (&BeginTime), rc);
1500	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime) (&EndTime), rc);
1501	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent) (&BytesSent), rc);
1502	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal) (&BytesSentTotal), rc);
1503	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived) (&BytesReceived), rc);
1504	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);
1505	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User) (User.asOutParam ()), rc);
1506	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain) (Domain.asOutParam ()), rc);
1507	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName) (ClientName.asOutParam ()), rc);
1508	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP) (ClientIP.asOutParam ()), rc);
1509	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion) (&ClientVersion), rc);
1510	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle) (&EncryptionStyle), rc);
1511
1512	if (details == VMINFO_MACHINEREADABLE)
1513	RTPrintf("VRDPActiveConnection=\"%s\"\n", Active ? "on": "off");
1514	else
1515	RTPrintf("VRDP Connection: %s\n", Active? "active": "not active");
1516
1517	if (details == VMINFO_MACHINEREADABLE)
1518	RTPrintf("VRDPClients=%d\n", NumberOfClients);
1519	else
1520	RTPrintf("Clients so far: %d\n", NumberOfClients);
1521
1522	if (NumberOfClients > 0)
1523	{
1524	char timestr[128];
1525
1526	if (Active)
1527	{
1528	makeTimeStr (timestr, sizeof (timestr), BeginTime);
1529	if (details == VMINFO_MACHINEREADABLE)
1530	RTPrintf("VRDPStartTime=\"%s\"\n", timestr);
1531	else
1532	RTPrintf("Start time: %s\n", timestr);
1533	}
1534	else
1535	{
1536	makeTimeStr (timestr, sizeof (timestr), BeginTime);
1537	if (details == VMINFO_MACHINEREADABLE)
1538	RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);
1539	else
1540	RTPrintf("Last started: %s\n", timestr);
1541	makeTimeStr (timestr, sizeof (timestr), EndTime);
1542	if (details == VMINFO_MACHINEREADABLE)
1543	RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);
1544	else
1545	RTPrintf("Last ended: %s\n", timestr);
1546	}
1547
1548	uint64_t ThroughputSend = 0;
1549	uint64_t ThroughputReceive = 0;
1550	if (EndTime != BeginTime)
1551	{
1552	ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime);
1553	ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
1554	}
1555
1556	if (details == VMINFO_MACHINEREADABLE)
1557	{
1558	RTPrintf("VRDPBytesSent=%llu\n", BytesSent);
1559	RTPrintf("VRDPThroughputSend=%llu\n", ThroughputSend);
1560	RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);
1561
1562	RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);
1563	RTPrintf("VRDPThroughputReceive=%llu\n", ThroughputReceive);
1564	RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);
1565	}
1566	else
1567	{
1568	RTPrintf("Sent: %llu Bytes\n", BytesSent);
1569	RTPrintf("Average speed: %llu B/s\n", ThroughputSend);
1570	RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);
1571
1572	RTPrintf("Received: %llu Bytes\n", BytesReceived);
1573	RTPrintf("Speed: %llu B/s\n", ThroughputReceive);
1574	RTPrintf("Received total: %llu Bytes\n", BytesReceivedTotal);
1575	}
1576
1577	if (Active)
1578	{
1579	if (details == VMINFO_MACHINEREADABLE)
1580	{
1581	RTPrintf("VRDPUserName=\"%lS\"\n", User.raw());
1582	RTPrintf("VRDPDomain=\"%lS\"\n", Domain.raw());
1583	RTPrintf("VRDPClientName=\"%lS\"\n", ClientName.raw());
1584	RTPrintf("VRDPClientIP=\"%lS\"\n", ClientIP.raw());
1585	RTPrintf("VRDPClientVersion=%d\n", ClientVersion);
1586	RTPrintf("VRDPEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1587	}
1588	else
1589	{
1590	RTPrintf("User name: %lS\n", User.raw());
1591	RTPrintf("Domain: %lS\n", Domain.raw());
1592	RTPrintf("Client name: %lS\n", ClientName.raw());
1593	RTPrintf("Client IP: %lS\n", ClientIP.raw());
1594	RTPrintf("Client version: %d\n", ClientVersion);
1595	RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1596	}
1597	}
1598	}
1599
1600	if (details != VMINFO_MACHINEREADABLE)
1601	RTPrintf("\n");
1602	}
1603
1604	if ( details == VMINFO_STANDARD
1605	\|\| details == VMINFO_FULL
1606	\|\| details == VMINFO_MACHINEREADABLE)
1607	{
1608	Bstr description;
1609	machine->COMGETTER(Description)(description.asOutParam());
1610	if (!description.isEmpty())
1611	{
1612	if (details == VMINFO_MACHINEREADABLE)
1613	RTPrintf("description=\"%lS\"\n", description.raw());
1614	else
1615	RTPrintf("Description:\n%lS\n", description.raw());
1616	}
1617	}
1618
1619	ULONG guestVal;
1620	if (details != VMINFO_MACHINEREADABLE)
1621	RTPrintf("Guest:\n\n");
1622
1623	#ifdef VBOX_WITH_MEM_BALLOONING
1624	rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);
1625	if (SUCCEEDED(rc))
1626	{
1627	if (details == VMINFO_MACHINEREADABLE)
1628	RTPrintf("GuestMemoryBalloon=%d\n", guestVal);
1629	else
1630	RTPrintf("Configured memory balloon size: %d MB\n", guestVal);
1631	}
1632	#endif
1633	rc = machine->COMGETTER(StatisticsUpdateInterval)(&guestVal);
1634	if (SUCCEEDED(rc))
1635	{
1636	if (details == VMINFO_MACHINEREADABLE)
1637	RTPrintf("GuestStatisticsUpdateInterval=%d\n", guestVal);
1638	else
1639	{
1640	if (guestVal == 0)
1641	RTPrintf("Statistics update: disabled\n");
1642	else
1643	RTPrintf("Statistics update interval: %d seconds\n", guestVal);
1644	}
1645	}
1646	if (details != VMINFO_MACHINEREADABLE)
1647	RTPrintf("\n");
1648
1649	if ( console
1650	&& ( details == VMINFO_STATISTICS
1651	\|\| details == VMINFO_FULL
1652	\|\| details == VMINFO_MACHINEREADABLE))
1653	{
1654	ComPtr <IGuest> guest;
1655
1656	rc = console->COMGETTER(Guest)(guest.asOutParam());
1657	if (SUCCEEDED(rc))
1658	{
1659	ULONG statVal;
1660
1661	rc = guest->GetStatistic(0, GuestStatisticType_SampleNumber, &statVal);
1662	if (details == VMINFO_MACHINEREADABLE)
1663	RTPrintf("StatGuestSample=%d\n", statVal);
1664	else
1665	RTPrintf("Guest statistics for sample %d:\n\n", statVal);
1666
1667	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Idle, &statVal);
1668	if (SUCCEEDED(rc))
1669	{
1670	if (details == VMINFO_MACHINEREADABLE)
1671	RTPrintf("StatGuestLoadIdleCPU%d=%d\n", 0, statVal);
1672	else
1673	RTPrintf("CPU%d: CPU Load Idle %-3d%%\n", 0, statVal);
1674	}
1675
1676	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Kernel, &statVal);
1677	if (SUCCEEDED(rc))
1678	{
1679	if (details == VMINFO_MACHINEREADABLE)
1680	RTPrintf("StatGuestLoadKernelCPU%d=%d\n", 0, statVal);
1681	else
1682	RTPrintf("CPU%d: CPU Load Kernel %-3d%%\n", 0, statVal);
1683	}
1684
1685	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_User, &statVal);
1686	if (SUCCEEDED(rc))
1687	{
1688	if (details == VMINFO_MACHINEREADABLE)
1689	RTPrintf("StatGuestLoadUserCPU%d=%d\n", 0, statVal);
1690	else
1691	RTPrintf("CPU%d: CPU Load User %-3d%%\n", 0, statVal);
1692	}
1693
1694	rc = guest->GetStatistic(0, GuestStatisticType_Threads, &statVal);
1695	if (SUCCEEDED(rc))
1696	{
1697	if (details == VMINFO_MACHINEREADABLE)
1698	RTPrintf("StatGuestThreadsCPU%d=%d\n", 0, statVal);
1699	else
1700	RTPrintf("CPU%d: Threads %d\n", 0, statVal);
1701	}
1702
1703	rc = guest->GetStatistic(0, GuestStatisticType_Processes, &statVal);
1704	if (SUCCEEDED(rc))
1705	{
1706	if (details == VMINFO_MACHINEREADABLE)
1707	RTPrintf("StatGuestProcessesCPU%d=%d\n", 0, statVal);
1708	else
1709	RTPrintf("CPU%d: Processes %d\n", 0, statVal);
1710	}
1711
1712	rc = guest->GetStatistic(0, GuestStatisticType_Handles, &statVal);
1713	if (SUCCEEDED(rc))
1714	{
1715	if (details == VMINFO_MACHINEREADABLE)
1716	RTPrintf("StatGuestHandlesCPU%d=%d\n", 0, statVal);
1717	else
1718	RTPrintf("CPU%d: Handles %d\n", 0, statVal);
1719	}
1720
1721	rc = guest->GetStatistic(0, GuestStatisticType_MemoryLoad, &statVal);
1722	if (SUCCEEDED(rc))
1723	{
1724	if (details == VMINFO_MACHINEREADABLE)
1725	RTPrintf("StatGuestMemoryLoadCPU%d=%d\n", 0, statVal);
1726	else
1727	RTPrintf("CPU%d: Memory Load %d%%\n", 0, statVal);
1728	}
1729
1730	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemTotal, &statVal);
1731	if (SUCCEEDED(rc))
1732	{
1733	if (details == VMINFO_MACHINEREADABLE)
1734	RTPrintf("StatGuestMemoryTotalPhysCPU%d=%d\n", 0, statVal);
1735	else
1736	RTPrintf("CPU%d: Total physical memory %-4d MB\n", 0, statVal);
1737	}
1738
1739	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemAvailable, &statVal);
1740	if (SUCCEEDED(rc))
1741	{
1742	if (details == VMINFO_MACHINEREADABLE)
1743	RTPrintf("StatGuestMemoryFreePhysCPU%d=%d\n", 0, statVal);
1744	else
1745	RTPrintf("CPU%d: Free physical memory %-4d MB\n", 0, statVal);
1746	}
1747
1748	#ifdef VBOX_WITH_MEM_BALLOONING
1749	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemBalloon, &statVal);
1750	if (SUCCEEDED(rc))
1751	{
1752	if (details == VMINFO_MACHINEREADABLE)
1753	RTPrintf("StatGuestMemoryBalloonCPU%d=%d\n", 0, statVal);
1754	else
1755	RTPrintf("CPU%d: Memory balloon size %-4d MB\n", 0, statVal);
1756	}
1757	#endif
1758	rc = guest->GetStatistic(0, GuestStatisticType_MemCommitTotal, &statVal);
1759	if (SUCCEEDED(rc))
1760	{
1761	if (details == VMINFO_MACHINEREADABLE)
1762	RTPrintf("StatGuestMemoryCommittedCPU%d=%d\n", 0, statVal);
1763	else
1764	RTPrintf("CPU%d: Committed memory %-4d MB\n", 0, statVal);
1765	}
1766
1767	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelTotal, &statVal);
1768	if (SUCCEEDED(rc))
1769	{
1770	if (details == VMINFO_MACHINEREADABLE)
1771	RTPrintf("StatGuestMemoryTotalKernelCPU%d=%d\n", 0, statVal);
1772	else
1773	RTPrintf("CPU%d: Total kernel memory %-4d MB\n", 0, statVal);
1774	}
1775
1776	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelPaged, &statVal);
1777	if (SUCCEEDED(rc))
1778	{
1779	if (details == VMINFO_MACHINEREADABLE)
1780	RTPrintf("StatGuestMemoryPagedKernelCPU%d=%d\n", 0, statVal);
1781	else
1782	RTPrintf("CPU%d: Paged kernel memory %-4d MB\n", 0, statVal);
1783	}
1784
1785	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelNonpaged, &statVal);
1786	if (SUCCEEDED(rc))
1787	{
1788	if (details == VMINFO_MACHINEREADABLE)
1789	RTPrintf("StatGuestMemoryNonpagedKernelCPU%d=%d\n", 0, statVal);
1790	else
1791	RTPrintf("CPU%d: Nonpaged kernel memory %-4d MB\n", 0, statVal);
1792	}
1793
1794	rc = guest->GetStatistic(0, GuestStatisticType_MemSystemCache, &statVal);
1795	if (SUCCEEDED(rc))
1796	{
1797	if (details == VMINFO_MACHINEREADABLE)
1798	RTPrintf("StatGuestSystemCacheSizeCPU%d=%d\n", 0, statVal);
1799	else
1800	RTPrintf("CPU%d: System cache size %-4d MB\n", 0, statVal);
1801	}
1802
1803	rc = guest->GetStatistic(0, GuestStatisticType_PageFileSize, &statVal);
1804	if (SUCCEEDED(rc))
1805	{
1806	if (details == VMINFO_MACHINEREADABLE)
1807	RTPrintf("StatGuestPageFileSizeCPU%d=%d\n", 0, statVal);
1808	else
1809	RTPrintf("CPU%d: Page file size %-4d MB\n", 0, statVal);
1810	}
1811
1812	RTPrintf("\n");
1813	}
1814	else
1815	{
1816	if (details != VMINFO_MACHINEREADABLE)
1817	{
1818	RTPrintf("[!] FAILED calling console->getGuest at line %d!\n", __LINE__);
1819	GluePrintRCMessage(rc);
1820	}
1821	}
1822	}
1823
1824	/*
1825	* snapshots
1826	*/
1827	ComPtr<ISnapshot> snapshot;
1828	rc = machine->GetSnapshot(Guid(), snapshot.asOutParam());
1829	if (SUCCEEDED(rc) && snapshot)
1830	{
1831	if (details != VMINFO_MACHINEREADABLE)
1832	RTPrintf("Snapshots:\n\n");
1833	showSnapshots(snapshot, details);
1834	}
1835
1836	if (details != VMINFO_MACHINEREADABLE)
1837	RTPrintf("\n");
1838	return S_OK;
1839	}
1840
1841	#if defined(_MSC_VER)
1842	# pragma optimize("", on)
1843	#endif
1844
1845	int handleShowVMInfo(HandlerArg *a)
1846	{
1847	HRESULT rc;
1848
1849	/* at least one option: the UUID or name of the VM */
1850	if (a->argc < 1)
1851	return errorSyntax(USAGE_SHOWVMINFO, "Incorrect number of parameters");
1852
1853	/* try to find the given machine */
1854	ComPtr <IMachine> machine;
1855	Guid uuid (a->argv[0]);
1856	if (!uuid.isEmpty())
1857	{
1858	CHECK_ERROR (a->virtualBox, GetMachine (uuid, machine.asOutParam()));
1859	}
1860	else
1861	{
1862	CHECK_ERROR (a->virtualBox, FindMachine (Bstr(a->argv[0]), machine.asOutParam()));
1863	if (SUCCEEDED (rc))
1864	machine->COMGETTER(Id) (uuid.asOutParam());
1865	}
1866	if (FAILED (rc))
1867	return 1;
1868
1869	/* 2nd option can be -details, -statistics or -argdump */
1870	VMINFO_DETAILS details = VMINFO_NONE;
1871	bool fDetails = false;
1872	bool fStatistics = false;
1873	bool fMachinereadable = false;
1874	for (int i=1;i<a->argc;i++)
1875	{
1876	if (!strcmp(a->argv[i], "-details"))
1877	fDetails = true;
1878	else
1879	if (!strcmp(a->argv[i], "-statistics"))
1880	fStatistics = true;
1881	if (!strcmp(a->argv[1], "-machinereadable"))
1882	fMachinereadable = true;
1883	}
1884	if (fMachinereadable)
1885	details = VMINFO_MACHINEREADABLE;
1886	else
1887	if (fDetails && fStatistics)
1888	details = VMINFO_FULL;
1889	else
1890	if (fDetails)
1891	details = VMINFO_STANDARD;
1892	else
1893	if (fStatistics)
1894	details = VMINFO_STATISTICS;
1895
1896	ComPtr <IConsole> console;
1897
1898	/* open an existing session for the VM */
1899	rc = a->virtualBox->OpenExistingSession (a->session, uuid);
1900	if (SUCCEEDED(rc))
1901	/* get the session machine */
1902	rc = a->session->COMGETTER(Machine)(machine.asOutParam());
1903	if (SUCCEEDED(rc))
1904	/* get the session console */
1905	rc = a->session->COMGETTER(Console)(console.asOutParam());
1906
1907	rc = showVMInfo(a->virtualBox, machine, details, console);
1908
1909	if (console)
1910	a->session->Close();
1911
1912	return SUCCEEDED (rc) ? 0 : 1;
1913	}
1914
1915	#endif /* !VBOX_ONLY_DOCS */
1916	/* 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@ 17766

Download in other formats: