VBoxManageInfo.cpp@ 18131

Last change on this file since 18131 was 18113, checked in by vboxsync, 16 years ago
don't spam the release log if Guest::GetStatistic() fails
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.2 KB

Line
1	/* $Id: VBoxManageInfo.cpp 18113 2009-03-20 12:54:04Z 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	#if defined(VBOX_WITH_NETFLT)
718	case NetworkAttachmentType_HostOnly:
719	{
720	Bstr strHostonlyAdp;
721	nic->COMGETTER(HostInterface)(strHostonlyAdp.asOutParam());
722	if (details == VMINFO_MACHINEREADABLE)
723	{
724	RTPrintf("hostonlyadapter%d=\"%lS\"\n", currentNIC + 1, strHostonlyAdp.raw());
725	strAttachment = "hostonly";
726	}
727	else
728	strAttachment = Utf8StrFmt("Host-only Interface '%lS'", strHostonlyAdp.raw());
729	break;
730	}
731	#endif
732	default:
733	strAttachment = "unknown";
734	break;
735	}
736
737	/* cable connected */
738	BOOL fConnected;
739	nic->COMGETTER(CableConnected)(&fConnected);
740
741	/* trace stuff */
742	BOOL fTraceEnabled;
743	nic->COMGETTER(TraceEnabled)(&fTraceEnabled);
744	Bstr traceFile;
745	nic->COMGETTER(TraceFile)(traceFile.asOutParam());
746
747	/* NIC type */
748	Utf8Str strNICType;
749	NetworkAdapterType_T NICType;
750	nic->COMGETTER(AdapterType)(&NICType);
751	switch (NICType) {
752	case NetworkAdapterType_Am79C970A:
753	strNICType = "Am79C970A";
754	break;
755	case NetworkAdapterType_Am79C973:
756	strNICType = "Am79C973";
757	break;
758	#ifdef VBOX_WITH_E1000
759	case NetworkAdapterType_I82540EM:
760	strNICType = "82540EM";
761	break;
762	case NetworkAdapterType_I82543GC:
763	strNICType = "82543GC";
764	break;
765	#endif
766	default:
767	strNICType = "unknown";
768	break;
769	}
770
771	/* reported line speed */
772	ULONG ulLineSpeed;
773	nic->COMGETTER(LineSpeed)(&ulLineSpeed);
774
775	if (details == VMINFO_MACHINEREADABLE)
776	{
777	RTPrintf("macaddress%d=\"%lS\"\n", currentNIC + 1, strMACAddress.raw());
778	RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off");
779	RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.raw());
780	}
781	else
782	RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Cable connected: %s, Trace: %s (file: %lS), Type: %s, Reported speed: %d Mbps\n",
783	currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),
784	fConnected ? "on" : "off",
785	fTraceEnabled ? "on" : "off",
786	traceFile.isEmpty() ? Bstr("none").raw() : traceFile.raw(),
787	strNICType.raw(),
788	ulLineSpeed / 1000);
789	}
790	}
791	}
792
793	/* get the maximum amount of UARTs */
794	ULONG maxUARTs = 0;
795	sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
796	for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
797	{
798	ComPtr<ISerialPort> uart;
799	rc = machine->GetSerialPort(currentUART, uart.asOutParam());
800	if (SUCCEEDED(rc) && uart)
801	{
802	BOOL fEnabled;
803	uart->COMGETTER(Enabled)(&fEnabled);
804	if (!fEnabled)
805	{
806	if (details == VMINFO_MACHINEREADABLE)
807	RTPrintf("uart%d=\"off\"\n", currentUART + 1);
808	else
809	RTPrintf("UART %d: disabled\n", currentUART + 1);
810	}
811	else
812	{
813	ULONG ulIRQ, ulIOBase;
814	PortMode_T HostMode;
815	Bstr path;
816	BOOL fServer;
817	uart->COMGETTER(IRQ)(&ulIRQ);
818	uart->COMGETTER(IOBase)(&ulIOBase);
819	uart->COMGETTER(Path)(path.asOutParam());
820	uart->COMGETTER(Server)(&fServer);
821	uart->COMGETTER(HostMode)(&HostMode);
822
823	if (details == VMINFO_MACHINEREADABLE)
824	RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,
825	ulIOBase, ulIRQ);
826	else
827	RTPrintf("UART %d: I/O base: 0x%04x, IRQ: %d",
828	currentUART + 1, ulIOBase, ulIRQ);
829	switch (HostMode)
830	{
831	default:
832	case PortMode_Disconnected:
833	if (details == VMINFO_MACHINEREADABLE)
834	RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
835	else
836	RTPrintf(", disconnected\n");
837	break;
838	case PortMode_HostPipe:
839	if (details == VMINFO_MACHINEREADABLE)
840	RTPrintf("uartmode%d=\"%s,%lS\"\n", currentUART + 1,
841	fServer ? "server" : "client", path.raw());
842	else
843	RTPrintf(", attached to pipe (%s) '%lS'\n",
844	fServer ? "server" : "client", path.raw());
845	break;
846	case PortMode_HostDevice:
847	if (details == VMINFO_MACHINEREADABLE)
848	RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
849	path.raw());
850	else
851	RTPrintf(", attached to device '%lS'\n", path.raw());
852	break;
853	}
854	}
855	}
856	}
857
858	ComPtr<IAudioAdapter> AudioAdapter;
859	rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
860	if (SUCCEEDED(rc))
861	{
862	const char *pszDrv = "Unknown";
863	const char *pszCtrl = "Unknown";
864	BOOL fEnabled;
865	rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
866	if (SUCCEEDED(rc) && fEnabled)
867	{
868	AudioDriverType_T enmDrvType;
869	rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
870	switch (enmDrvType)
871	{
872	case AudioDriverType_Null:
873	if (details == VMINFO_MACHINEREADABLE)
874	pszDrv = "null";
875	else
876	pszDrv = "Null";
877	break;
878	case AudioDriverType_WinMM:
879	if (details == VMINFO_MACHINEREADABLE)
880	pszDrv = "winmm";
881	else
882	pszDrv = "WINMM";
883	break;
884	case AudioDriverType_DirectSound:
885	if (details == VMINFO_MACHINEREADABLE)
886	pszDrv = "dsound";
887	else
888	pszDrv = "DSOUND";
889	break;
890	case AudioDriverType_OSS:
891	if (details == VMINFO_MACHINEREADABLE)
892	pszDrv = "oss";
893	else
894	pszDrv = "OSS";
895	break;
896	case AudioDriverType_ALSA:
897	if (details == VMINFO_MACHINEREADABLE)
898	pszDrv = "alsa";
899	else
900	pszDrv = "ALSA";
901	break;
902	case AudioDriverType_Pulse:
903	if (details == VMINFO_MACHINEREADABLE)
904	pszDrv = "pulse";
905	else
906	pszDrv = "PulseAudio";
907	break;
908	case AudioDriverType_CoreAudio:
909	if (details == VMINFO_MACHINEREADABLE)
910	pszDrv = "coreaudio";
911	else
912	pszDrv = "CoreAudio";
913	break;
914	case AudioDriverType_SolAudio:
915	if (details == VMINFO_MACHINEREADABLE)
916	pszDrv = "solaudio";
917	else
918	pszDrv = "SolAudio";
919	break;
920	default:
921	if (details == VMINFO_MACHINEREADABLE)
922	pszDrv = "unknown";
923	break;
924	}
925	AudioControllerType_T enmCtrlType;
926	rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
927	switch (enmCtrlType)
928	{
929	case AudioControllerType_AC97:
930	if (details == VMINFO_MACHINEREADABLE)
931	pszCtrl = "ac97";
932	else
933	pszCtrl = "AC97";
934	break;
935	case AudioControllerType_SB16:
936	if (details == VMINFO_MACHINEREADABLE)
937	pszCtrl = "sb16";
938	else
939	pszCtrl = "SB16";
940	break;
941	}
942	}
943	else
944	fEnabled = FALSE;
945	if (details == VMINFO_MACHINEREADABLE)
946	{
947	if (fEnabled)
948	RTPrintf("audio=\"%s\"\n", pszDrv);
949	else
950	RTPrintf("audio=\"none\"\n");
951	}
952	else
953	RTPrintf("Audio: %s (Driver: %s, Controller: %s)\n",
954	fEnabled ? "enabled" : "disabled", pszDrv, pszCtrl);
955	}
956
957	/* Shared clipboard */
958	{
959	const char *psz = "Unknown";
960	ClipboardMode_T enmMode;
961	rc = machine->COMGETTER(ClipboardMode)(&enmMode);
962	switch (enmMode)
963	{
964	case ClipboardMode_Disabled:
965	if (details == VMINFO_MACHINEREADABLE)
966	psz = "disabled";
967	else
968	psz = "disabled";
969	break;
970	case ClipboardMode_HostToGuest:
971	if (details == VMINFO_MACHINEREADABLE)
972	psz = "hosttoguest";
973	else
974	psz = "HostToGuest";
975	break;
976	case ClipboardMode_GuestToHost:
977	if (details == VMINFO_MACHINEREADABLE)
978	psz = "guesttohost";
979	else
980	psz = "GuestToHost";
981	break;
982	case ClipboardMode_Bidirectional:
983	if (details == VMINFO_MACHINEREADABLE)
984	psz = "bidirectional";
985	else
986	psz = "Bidirectional";
987	break;
988	default:
989	if (details == VMINFO_MACHINEREADABLE)
990	psz = "unknown";
991	break;
992	}
993	if (details == VMINFO_MACHINEREADABLE)
994	RTPrintf("clipboard=\"%s\"\n", psz);
995	else
996	RTPrintf("Clipboard Mode: %s\n", psz);
997	}
998
999	if (console)
1000	{
1001	ComPtr<IDisplay> display;
1002	CHECK_ERROR_RET(console, COMGETTER(Display)(display.asOutParam()), rc);
1003	do
1004	{
1005	ULONG xRes, yRes, bpp;
1006	rc = display->COMGETTER(Width)(&xRes);
1007	if (rc == E_ACCESSDENIED)
1008	break; /* VM not powered up */
1009	if (FAILED(rc))
1010	{
1011	com::ErrorInfo info (display);
1012	GluePrintErrorInfo(info);
1013	return rc;
1014	}
1015	rc = display->COMGETTER(Height)(&yRes);
1016	if (rc == E_ACCESSDENIED)
1017	break; /* VM not powered up */
1018	if (FAILED(rc))
1019	{
1020	com::ErrorInfo info (display);
1021	GluePrintErrorInfo(info);
1022	return rc;
1023	}
1024	rc = display->COMGETTER(BitsPerPixel)(&bpp);
1025	if (rc == E_ACCESSDENIED)
1026	break; /* VM not powered up */
1027	if (FAILED(rc))
1028	{
1029	com::ErrorInfo info (display);
1030	GluePrintErrorInfo(info);
1031	return rc;
1032	}
1033	if (details == VMINFO_MACHINEREADABLE)
1034	RTPrintf("VideoMode=\"%d,%d,%d\"\n", xRes, yRes, bpp);
1035	else
1036	RTPrintf("Video mode: %dx%dx%d\n", xRes, yRes, bpp);
1037	}
1038	while (0);
1039	}
1040
1041	/*
1042	* VRDP
1043	*/
1044	ComPtr<IVRDPServer> vrdpServer;
1045	rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1046	if (SUCCEEDED(rc) && vrdpServer)
1047	{
1048	BOOL fEnabled = false;
1049	vrdpServer->COMGETTER(Enabled)(&fEnabled);
1050	if (fEnabled)
1051	{
1052	ULONG port;
1053	vrdpServer->COMGETTER(Port)(&port);
1054	Bstr address;
1055	vrdpServer->COMGETTER(NetAddress)(address.asOutParam());
1056	BOOL fMultiCon;
1057	vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
1058	BOOL fReuseCon;
1059	vrdpServer->COMGETTER(ReuseSingleConnection)(&fReuseCon);
1060	VRDPAuthType_T vrdpAuthType;
1061	const char *strAuthType;
1062	vrdpServer->COMGETTER(AuthType)(&vrdpAuthType);
1063	switch (vrdpAuthType)
1064	{
1065	case VRDPAuthType_Null:
1066	strAuthType = "null";
1067	break;
1068	case VRDPAuthType_External:
1069	strAuthType = "external";
1070	break;
1071	case VRDPAuthType_Guest:
1072	strAuthType = "guest";
1073	break;
1074	default:
1075	strAuthType = "unknown";
1076	break;
1077	}
1078	if (details == VMINFO_MACHINEREADABLE)
1079	{
1080	RTPrintf("vrdp=\"on\"\n");
1081	RTPrintf("vrdpport=%d\n", port);
1082	RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());
1083	RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);
1084	RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");
1085	RTPrintf("vrdpreusecon=\"%s\"\n", fReuseCon ? "on" : "off");
1086	}
1087	else
1088	{
1089	if (address.isEmpty())
1090	address = "0.0.0.0";
1091	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);
1092	}
1093	}
1094	else
1095	{
1096	if (details == VMINFO_MACHINEREADABLE)
1097	RTPrintf("vrdp=\"off\"\n");
1098	else
1099	RTPrintf("VRDP: disabled\n");
1100	}
1101	}
1102
1103	/*
1104	* USB.
1105	*/
1106	ComPtr<IUSBController> USBCtl;
1107	rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());
1108	if (SUCCEEDED(rc))
1109	{
1110	BOOL fEnabled;
1111	rc = USBCtl->COMGETTER(Enabled)(&fEnabled);
1112	if (FAILED(rc))
1113	fEnabled = false;
1114	if (details == VMINFO_MACHINEREADABLE)
1115	RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");
1116	else
1117	RTPrintf("USB: %s\n", fEnabled ? "enabled" : "disabled");
1118
1119	if (details != VMINFO_MACHINEREADABLE)
1120	RTPrintf("\nUSB Device Filters:\n\n");
1121
1122	SafeIfaceArray <IUSBDeviceFilter> Coll;
1123	CHECK_ERROR_RET (USBCtl, COMGETTER(DeviceFilters)(ComSafeArrayAsOutParam(Coll)), rc);
1124
1125	if (Coll.size() == 0)
1126	{
1127	if (details != VMINFO_MACHINEREADABLE)
1128	RTPrintf("<none>\n\n");
1129	}
1130	else
1131	{
1132	for (size_t index = 0; index < Coll.size(); ++index)
1133	{
1134	ComPtr<IUSBDeviceFilter> DevPtr = Coll[index];
1135
1136	/* Query info. */
1137
1138	if (details != VMINFO_MACHINEREADABLE)
1139	RTPrintf("Index: %zu\n", index);
1140
1141	BOOL bActive = FALSE;
1142	CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
1143	if (details == VMINFO_MACHINEREADABLE)
1144	RTPrintf("USBFilterActive%zu=\"%s\"\n", index + 1, bActive ? "on" : "off");
1145	else
1146	RTPrintf("Active: %s\n", bActive ? "yes" : "no");
1147
1148	Bstr bstr;
1149	CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);
1150	if (details == VMINFO_MACHINEREADABLE)
1151	RTPrintf("USBFilterName%zu=\"%lS\"\n", index + 1, bstr.raw());
1152	else
1153	RTPrintf("Name: %lS\n", bstr.raw());
1154	CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);
1155	if (details == VMINFO_MACHINEREADABLE)
1156	RTPrintf("USBFilterVendorId%zu=\"%lS\"\n", index + 1, bstr.raw());
1157	else
1158	RTPrintf("VendorId: %lS\n", bstr.raw());
1159	CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);
1160	if (details == VMINFO_MACHINEREADABLE)
1161	RTPrintf("USBFilterProductId%zu=\"%lS\"\n", index + 1, bstr.raw());
1162	else
1163	RTPrintf("ProductId: %lS\n", bstr.raw());
1164	CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);
1165	if (details == VMINFO_MACHINEREADABLE)
1166	RTPrintf("USBFilterRevision%zu=\"%lS\"\n", index + 1, bstr.raw());
1167	else
1168	RTPrintf("Revision: %lS\n", bstr.raw());
1169	CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);
1170	if (details == VMINFO_MACHINEREADABLE)
1171	RTPrintf("USBFilterManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1172	else
1173	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1174	CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);
1175	if (details == VMINFO_MACHINEREADABLE)
1176	RTPrintf("USBFilterProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1177	else
1178	RTPrintf("Product: %lS\n", bstr.raw());
1179	CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);
1180	if (details == VMINFO_MACHINEREADABLE)
1181	RTPrintf("USBFilterRemote%zu=\"%lS\"\n", index + 1, bstr.raw());
1182	else
1183	RTPrintf("Remote: %lS\n", bstr.raw());
1184	CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);
1185	if (details == VMINFO_MACHINEREADABLE)
1186	RTPrintf("USBFilterSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1187	else
1188	RTPrintf("Serial Number: %lS\n", bstr.raw());
1189	if (details != VMINFO_MACHINEREADABLE)
1190	{
1191	ULONG fMaskedIfs;
1192	CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);
1193	if (fMaskedIfs)
1194	RTPrintf("Masked Interfaces: 0x%08x\n", fMaskedIfs);
1195	RTPrintf("\n");
1196	}
1197	}
1198	}
1199
1200	if (console)
1201	{
1202	/* scope */
1203	{
1204	if (details != VMINFO_MACHINEREADABLE)
1205	RTPrintf("Available remote USB devices:\n\n");
1206
1207	SafeIfaceArray <IHostUSBDevice> coll;
1208	CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1209
1210	if (coll.size() == 0)
1211	{
1212	if (details != VMINFO_MACHINEREADABLE)
1213	RTPrintf("<none>\n\n");
1214	}
1215	else
1216	{
1217	for (size_t index = 0; index < coll.size(); ++index)
1218	{
1219	ComPtr <IHostUSBDevice> dev = coll[index];
1220
1221	/* Query info. */
1222	Guid id;
1223	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1224	USHORT usVendorId;
1225	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1226	USHORT usProductId;
1227	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1228	USHORT bcdRevision;
1229	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1230
1231	if (details == VMINFO_MACHINEREADABLE)
1232	RTPrintf("USBRemoteUUID%zu=\"%S\"\n"
1233	"USBRemoteVendorId%zu=\"%#06x\"\n"
1234	"USBRemoteProductId%zu=\"%#06x\"\n"
1235	"USBRemoteRevision%zu=\"%#04x%02x\"\n",
1236	index + 1, id.toString().raw(),
1237	index + 1, usVendorId,
1238	index + 1, usProductId,
1239	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1240	else
1241	RTPrintf("UUID: %S\n"
1242	"VendorId: 0x%04x (%04X)\n"
1243	"ProductId: 0x%04x (%04X)\n"
1244	"Revision: %u.%u (%02u%02u)\n",
1245	id.toString().raw(),
1246	usVendorId, usVendorId, usProductId, usProductId,
1247	bcdRevision >> 8, bcdRevision & 0xff,
1248	bcdRevision >> 8, bcdRevision & 0xff);
1249
1250	/* optional stuff. */
1251	Bstr bstr;
1252	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1253	if (!bstr.isEmpty())
1254	{
1255	if (details == VMINFO_MACHINEREADABLE)
1256	RTPrintf("USBRemoteManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1257	else
1258	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1259	}
1260	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1261	if (!bstr.isEmpty())
1262	{
1263	if (details == VMINFO_MACHINEREADABLE)
1264	RTPrintf("USBRemoteProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1265	else
1266	RTPrintf("Product: %lS\n", bstr.raw());
1267	}
1268	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1269	if (!bstr.isEmpty())
1270	{
1271	if (details == VMINFO_MACHINEREADABLE)
1272	RTPrintf("USBRemoteSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1273	else
1274	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1275	}
1276	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1277	if (!bstr.isEmpty())
1278	{
1279	if (details == VMINFO_MACHINEREADABLE)
1280	RTPrintf("USBRemoteAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1281	else
1282	RTPrintf("Address: %lS\n", bstr.raw());
1283	}
1284
1285	if (details != VMINFO_MACHINEREADABLE)
1286	RTPrintf("\n");
1287	}
1288	}
1289	}
1290
1291	/* scope */
1292	{
1293	if (details != VMINFO_MACHINEREADABLE)
1294	RTPrintf ("Currently Attached USB Devices:\n\n");
1295
1296	SafeIfaceArray <IUSBDevice> coll;
1297	CHECK_ERROR_RET (console, COMGETTER(USBDevices) (ComSafeArrayAsOutParam(coll)), rc);
1298
1299	if (coll.size() == 0)
1300	{
1301	if (details != VMINFO_MACHINEREADABLE)
1302	RTPrintf("<none>\n\n");
1303	}
1304	else
1305	{
1306	for (size_t index = 0; index < coll.size(); ++index)
1307	{
1308	ComPtr <IUSBDevice> dev = coll[index];
1309
1310	/* Query info. */
1311	Guid id;
1312	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1313	USHORT usVendorId;
1314	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1315	USHORT usProductId;
1316	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1317	USHORT bcdRevision;
1318	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1319
1320	if (details == VMINFO_MACHINEREADABLE)
1321	RTPrintf("USBAttachedUUID%zu=\"%S\"\n"
1322	"USBAttachedVendorId%zu=\"%#06x\"\n"
1323	"USBAttachedProductId%zu=\"%#06x\"\n"
1324	"USBAttachedRevision%zu=\"%#04x%02x\"\n",
1325	index + 1, id.toString().raw(),
1326	index + 1, usVendorId,
1327	index + 1, usProductId,
1328	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1329	else
1330	RTPrintf("UUID: %S\n"
1331	"VendorId: 0x%04x (%04X)\n"
1332	"ProductId: 0x%04x (%04X)\n"
1333	"Revision: %u.%u (%02u%02u)\n",
1334	id.toString().raw(),
1335	usVendorId, usVendorId, usProductId, usProductId,
1336	bcdRevision >> 8, bcdRevision & 0xff,
1337	bcdRevision >> 8, bcdRevision & 0xff);
1338
1339	/* optional stuff. */
1340	Bstr bstr;
1341	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1342	if (!bstr.isEmpty())
1343	{
1344	if (details == VMINFO_MACHINEREADABLE)
1345	RTPrintf("USBAttachedManufacturer%zu=\"%lS\"\n", index + 1, bstr.raw());
1346	else
1347	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1348	}
1349	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1350	if (!bstr.isEmpty())
1351	{
1352	if (details == VMINFO_MACHINEREADABLE)
1353	RTPrintf("USBAttachedProduct%zu=\"%lS\"\n", index + 1, bstr.raw());
1354	else
1355	RTPrintf("Product: %lS\n", bstr.raw());
1356	}
1357	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1358	if (!bstr.isEmpty())
1359	{
1360	if (details == VMINFO_MACHINEREADABLE)
1361	RTPrintf("USBAttachedSerialNumber%zu=\"%lS\"\n", index + 1, bstr.raw());
1362	else
1363	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1364	}
1365	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1366	if (!bstr.isEmpty())
1367	{
1368	if (details == VMINFO_MACHINEREADABLE)
1369	RTPrintf("USBAttachedAddress%zu=\"%lS\"\n", index + 1, bstr.raw());
1370	else
1371	RTPrintf("Address: %lS\n", bstr.raw());
1372	}
1373
1374	if (details != VMINFO_MACHINEREADABLE)
1375	RTPrintf("\n");
1376	}
1377	}
1378	}
1379	}
1380	} /* USB */
1381
1382	/*
1383	* Shared folders
1384	*/
1385	if (details != VMINFO_MACHINEREADABLE)
1386	RTPrintf("Shared folders: ");
1387	uint32_t numSharedFolders = 0;
1388	#if 0 // not yet implemented
1389	/* globally shared folders first */
1390	{
1391	SafeIfaceArray <ISharedFolder> sfColl;
1392	CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(sfColl)), rc);
1393	for (size_t i = 0; i < sfColl.size(); ++i)
1394	{
1395	ComPtr<ISharedFolder> sf = sfColl[i];
1396	Bstr name, hostPath;
1397	sf->COMGETTER(Name)(name.asOutParam());
1398	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1399	RTPrintf("Name: '%lS', Host path: '%lS' (global mapping)\n", name.raw(), hostPath.raw());
1400	++numSharedFolders;
1401	}
1402	}
1403	#endif
1404	/* now VM mappings */
1405	{
1406	com::SafeIfaceArray <ISharedFolder> folders;
1407
1408	CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1409
1410	for (size_t i = 0; i < folders.size(); ++i)
1411	{
1412	ComPtr <ISharedFolder> sf = folders[i];
1413
1414	Bstr name, hostPath;
1415	BOOL writable;
1416	sf->COMGETTER(Name)(name.asOutParam());
1417	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1418	sf->COMGETTER(Writable)(&writable);
1419	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1420	RTPrintf("\n\n");
1421	if (details == VMINFO_MACHINEREADABLE)
1422	{
1423	RTPrintf("SharedFolderNameMachineMapping%zu=\"%lS\"\n", i + 1,
1424	name.raw());
1425	RTPrintf("SharedFolderPathMachineMapping%zu=\"%lS\"\n", i + 1,
1426	hostPath.raw());
1427	}
1428	else
1429	RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
1430	name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
1431	++numSharedFolders;
1432	}
1433	}
1434	/* transient mappings */
1435	if (console)
1436	{
1437	com::SafeIfaceArray <ISharedFolder> folders;
1438
1439	CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders)), rc);
1440
1441	for (size_t i = 0; i < folders.size(); ++i)
1442	{
1443	ComPtr <ISharedFolder> sf = folders[i];
1444
1445	Bstr name, hostPath;
1446	sf->COMGETTER(Name)(name.asOutParam());
1447	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1448	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1449	RTPrintf("\n\n");
1450	if (details == VMINFO_MACHINEREADABLE)
1451	{
1452	RTPrintf("SharedFolderNameTransientMapping%zu=\"%lS\"\n", i + 1,
1453	name.raw());
1454	RTPrintf("SharedFolderPathTransientMapping%zu=\"%lS\"\n", i + 1,
1455	hostPath.raw());
1456	}
1457	else
1458	RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());
1459	++numSharedFolders;
1460	}
1461	}
1462	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1463	RTPrintf("<none>\n");
1464	if (details != VMINFO_MACHINEREADABLE)
1465	RTPrintf("\n");
1466
1467	if (console)
1468	{
1469	/*
1470	* Live VRDP info.
1471	*/
1472	ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
1473	CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
1474	BOOL Active;
1475	ULONG NumberOfClients;
1476	LONG64 BeginTime;
1477	LONG64 EndTime;
1478	ULONG64 BytesSent;
1479	ULONG64 BytesSentTotal;
1480	ULONG64 BytesReceived;
1481	ULONG64 BytesReceivedTotal;
1482	Bstr User;
1483	Bstr Domain;
1484	Bstr ClientName;
1485	Bstr ClientIP;
1486	ULONG ClientVersion;
1487	ULONG EncryptionStyle;
1488
1489	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active) (&Active), rc);
1490	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients) (&NumberOfClients), rc);
1491	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime) (&BeginTime), rc);
1492	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime) (&EndTime), rc);
1493	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent) (&BytesSent), rc);
1494	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal) (&BytesSentTotal), rc);
1495	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived) (&BytesReceived), rc);
1496	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);
1497	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User) (User.asOutParam ()), rc);
1498	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain) (Domain.asOutParam ()), rc);
1499	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName) (ClientName.asOutParam ()), rc);
1500	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP) (ClientIP.asOutParam ()), rc);
1501	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion) (&ClientVersion), rc);
1502	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle) (&EncryptionStyle), rc);
1503
1504	if (details == VMINFO_MACHINEREADABLE)
1505	RTPrintf("VRDPActiveConnection=\"%s\"\n", Active ? "on": "off");
1506	else
1507	RTPrintf("VRDP Connection: %s\n", Active? "active": "not active");
1508
1509	if (details == VMINFO_MACHINEREADABLE)
1510	RTPrintf("VRDPClients=%d\n", NumberOfClients);
1511	else
1512	RTPrintf("Clients so far: %d\n", NumberOfClients);
1513
1514	if (NumberOfClients > 0)
1515	{
1516	char timestr[128];
1517
1518	if (Active)
1519	{
1520	makeTimeStr (timestr, sizeof (timestr), BeginTime);
1521	if (details == VMINFO_MACHINEREADABLE)
1522	RTPrintf("VRDPStartTime=\"%s\"\n", timestr);
1523	else
1524	RTPrintf("Start time: %s\n", timestr);
1525	}
1526	else
1527	{
1528	makeTimeStr (timestr, sizeof (timestr), BeginTime);
1529	if (details == VMINFO_MACHINEREADABLE)
1530	RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);
1531	else
1532	RTPrintf("Last started: %s\n", timestr);
1533	makeTimeStr (timestr, sizeof (timestr), EndTime);
1534	if (details == VMINFO_MACHINEREADABLE)
1535	RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);
1536	else
1537	RTPrintf("Last ended: %s\n", timestr);
1538	}
1539
1540	uint64_t ThroughputSend = 0;
1541	uint64_t ThroughputReceive = 0;
1542	if (EndTime != BeginTime)
1543	{
1544	ThroughputSend = (BytesSent * 1000) / (EndTime - BeginTime);
1545	ThroughputReceive = (BytesReceived * 1000) / (EndTime - BeginTime);
1546	}
1547
1548	if (details == VMINFO_MACHINEREADABLE)
1549	{
1550	RTPrintf("VRDPBytesSent=%llu\n", BytesSent);
1551	RTPrintf("VRDPThroughputSend=%llu\n", ThroughputSend);
1552	RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);
1553
1554	RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);
1555	RTPrintf("VRDPThroughputReceive=%llu\n", ThroughputReceive);
1556	RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);
1557	}
1558	else
1559	{
1560	RTPrintf("Sent: %llu Bytes\n", BytesSent);
1561	RTPrintf("Average speed: %llu B/s\n", ThroughputSend);
1562	RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);
1563
1564	RTPrintf("Received: %llu Bytes\n", BytesReceived);
1565	RTPrintf("Speed: %llu B/s\n", ThroughputReceive);
1566	RTPrintf("Received total: %llu Bytes\n", BytesReceivedTotal);
1567	}
1568
1569	if (Active)
1570	{
1571	if (details == VMINFO_MACHINEREADABLE)
1572	{
1573	RTPrintf("VRDPUserName=\"%lS\"\n", User.raw());
1574	RTPrintf("VRDPDomain=\"%lS\"\n", Domain.raw());
1575	RTPrintf("VRDPClientName=\"%lS\"\n", ClientName.raw());
1576	RTPrintf("VRDPClientIP=\"%lS\"\n", ClientIP.raw());
1577	RTPrintf("VRDPClientVersion=%d\n", ClientVersion);
1578	RTPrintf("VRDPEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1579	}
1580	else
1581	{
1582	RTPrintf("User name: %lS\n", User.raw());
1583	RTPrintf("Domain: %lS\n", Domain.raw());
1584	RTPrintf("Client name: %lS\n", ClientName.raw());
1585	RTPrintf("Client IP: %lS\n", ClientIP.raw());
1586	RTPrintf("Client version: %d\n", ClientVersion);
1587	RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
1588	}
1589	}
1590	}
1591
1592	if (details != VMINFO_MACHINEREADABLE)
1593	RTPrintf("\n");
1594	}
1595
1596	if ( details == VMINFO_STANDARD
1597	\|\| details == VMINFO_FULL
1598	\|\| details == VMINFO_MACHINEREADABLE)
1599	{
1600	Bstr description;
1601	machine->COMGETTER(Description)(description.asOutParam());
1602	if (!description.isEmpty())
1603	{
1604	if (details == VMINFO_MACHINEREADABLE)
1605	RTPrintf("description=\"%lS\"\n", description.raw());
1606	else
1607	RTPrintf("Description:\n%lS\n", description.raw());
1608	}
1609	}
1610
1611	ULONG guestVal;
1612	if (details != VMINFO_MACHINEREADABLE)
1613	RTPrintf("Guest:\n\n");
1614
1615	#ifdef VBOX_WITH_MEM_BALLOONING
1616	rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);
1617	if (SUCCEEDED(rc))
1618	{
1619	if (details == VMINFO_MACHINEREADABLE)
1620	RTPrintf("GuestMemoryBalloon=%d\n", guestVal);
1621	else
1622	RTPrintf("Configured memory balloon size: %d MB\n", guestVal);
1623	}
1624	#endif
1625	rc = machine->COMGETTER(StatisticsUpdateInterval)(&guestVal);
1626	if (SUCCEEDED(rc))
1627	{
1628	if (details == VMINFO_MACHINEREADABLE)
1629	RTPrintf("GuestStatisticsUpdateInterval=%d\n", guestVal);
1630	else
1631	{
1632	if (guestVal == 0)
1633	RTPrintf("Statistics update: disabled\n");
1634	else
1635	RTPrintf("Statistics update interval: %d seconds\n", guestVal);
1636	}
1637	}
1638	if (details != VMINFO_MACHINEREADABLE)
1639	RTPrintf("\n");
1640
1641	if ( console
1642	&& ( details == VMINFO_STATISTICS
1643	\|\| details == VMINFO_FULL
1644	\|\| details == VMINFO_MACHINEREADABLE))
1645	{
1646	ComPtr <IGuest> guest;
1647
1648	rc = console->COMGETTER(Guest)(guest.asOutParam());
1649	if (SUCCEEDED(rc))
1650	{
1651	ULONG statVal;
1652
1653	rc = guest->GetStatistic(0, GuestStatisticType_SampleNumber, &statVal);
1654	if (SUCCEEDED(rc))
1655	{
1656	if (details == VMINFO_MACHINEREADABLE)
1657	RTPrintf("StatGuestSample=%d\n", statVal);
1658	else
1659	RTPrintf("Guest statistics for sample %d:\n\n", statVal);
1660	}
1661
1662	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Idle, &statVal);
1663	if (SUCCEEDED(rc))
1664	{
1665	if (details == VMINFO_MACHINEREADABLE)
1666	RTPrintf("StatGuestLoadIdleCPU%d=%d\n", 0, statVal);
1667	else
1668	RTPrintf("CPU%d: CPU Load Idle %-3d%%\n", 0, statVal);
1669	}
1670
1671	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Kernel, &statVal);
1672	if (SUCCEEDED(rc))
1673	{
1674	if (details == VMINFO_MACHINEREADABLE)
1675	RTPrintf("StatGuestLoadKernelCPU%d=%d\n", 0, statVal);
1676	else
1677	RTPrintf("CPU%d: CPU Load Kernel %-3d%%\n", 0, statVal);
1678	}
1679
1680	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_User, &statVal);
1681	if (SUCCEEDED(rc))
1682	{
1683	if (details == VMINFO_MACHINEREADABLE)
1684	RTPrintf("StatGuestLoadUserCPU%d=%d\n", 0, statVal);
1685	else
1686	RTPrintf("CPU%d: CPU Load User %-3d%%\n", 0, statVal);
1687	}
1688
1689	rc = guest->GetStatistic(0, GuestStatisticType_Threads, &statVal);
1690	if (SUCCEEDED(rc))
1691	{
1692	if (details == VMINFO_MACHINEREADABLE)
1693	RTPrintf("StatGuestThreadsCPU%d=%d\n", 0, statVal);
1694	else
1695	RTPrintf("CPU%d: Threads %d\n", 0, statVal);
1696	}
1697
1698	rc = guest->GetStatistic(0, GuestStatisticType_Processes, &statVal);
1699	if (SUCCEEDED(rc))
1700	{
1701	if (details == VMINFO_MACHINEREADABLE)
1702	RTPrintf("StatGuestProcessesCPU%d=%d\n", 0, statVal);
1703	else
1704	RTPrintf("CPU%d: Processes %d\n", 0, statVal);
1705	}
1706
1707	rc = guest->GetStatistic(0, GuestStatisticType_Handles, &statVal);
1708	if (SUCCEEDED(rc))
1709	{
1710	if (details == VMINFO_MACHINEREADABLE)
1711	RTPrintf("StatGuestHandlesCPU%d=%d\n", 0, statVal);
1712	else
1713	RTPrintf("CPU%d: Handles %d\n", 0, statVal);
1714	}
1715
1716	rc = guest->GetStatistic(0, GuestStatisticType_MemoryLoad, &statVal);
1717	if (SUCCEEDED(rc))
1718	{
1719	if (details == VMINFO_MACHINEREADABLE)
1720	RTPrintf("StatGuestMemoryLoadCPU%d=%d\n", 0, statVal);
1721	else
1722	RTPrintf("CPU%d: Memory Load %d%%\n", 0, statVal);
1723	}
1724
1725	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemTotal, &statVal);
1726	if (SUCCEEDED(rc))
1727	{
1728	if (details == VMINFO_MACHINEREADABLE)
1729	RTPrintf("StatGuestMemoryTotalPhysCPU%d=%d\n", 0, statVal);
1730	else
1731	RTPrintf("CPU%d: Total physical memory %-4d MB\n", 0, statVal);
1732	}
1733
1734	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemAvailable, &statVal);
1735	if (SUCCEEDED(rc))
1736	{
1737	if (details == VMINFO_MACHINEREADABLE)
1738	RTPrintf("StatGuestMemoryFreePhysCPU%d=%d\n", 0, statVal);
1739	else
1740	RTPrintf("CPU%d: Free physical memory %-4d MB\n", 0, statVal);
1741	}
1742
1743	#ifdef VBOX_WITH_MEM_BALLOONING
1744	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemBalloon, &statVal);
1745	if (SUCCEEDED(rc))
1746	{
1747	if (details == VMINFO_MACHINEREADABLE)
1748	RTPrintf("StatGuestMemoryBalloonCPU%d=%d\n", 0, statVal);
1749	else
1750	RTPrintf("CPU%d: Memory balloon size %-4d MB\n", 0, statVal);
1751	}
1752	#endif
1753	rc = guest->GetStatistic(0, GuestStatisticType_MemCommitTotal, &statVal);
1754	if (SUCCEEDED(rc))
1755	{
1756	if (details == VMINFO_MACHINEREADABLE)
1757	RTPrintf("StatGuestMemoryCommittedCPU%d=%d\n", 0, statVal);
1758	else
1759	RTPrintf("CPU%d: Committed memory %-4d MB\n", 0, statVal);
1760	}
1761
1762	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelTotal, &statVal);
1763	if (SUCCEEDED(rc))
1764	{
1765	if (details == VMINFO_MACHINEREADABLE)
1766	RTPrintf("StatGuestMemoryTotalKernelCPU%d=%d\n", 0, statVal);
1767	else
1768	RTPrintf("CPU%d: Total kernel memory %-4d MB\n", 0, statVal);
1769	}
1770
1771	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelPaged, &statVal);
1772	if (SUCCEEDED(rc))
1773	{
1774	if (details == VMINFO_MACHINEREADABLE)
1775	RTPrintf("StatGuestMemoryPagedKernelCPU%d=%d\n", 0, statVal);
1776	else
1777	RTPrintf("CPU%d: Paged kernel memory %-4d MB\n", 0, statVal);
1778	}
1779
1780	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelNonpaged, &statVal);
1781	if (SUCCEEDED(rc))
1782	{
1783	if (details == VMINFO_MACHINEREADABLE)
1784	RTPrintf("StatGuestMemoryNonpagedKernelCPU%d=%d\n", 0, statVal);
1785	else
1786	RTPrintf("CPU%d: Nonpaged kernel memory %-4d MB\n", 0, statVal);
1787	}
1788
1789	rc = guest->GetStatistic(0, GuestStatisticType_MemSystemCache, &statVal);
1790	if (SUCCEEDED(rc))
1791	{
1792	if (details == VMINFO_MACHINEREADABLE)
1793	RTPrintf("StatGuestSystemCacheSizeCPU%d=%d\n", 0, statVal);
1794	else
1795	RTPrintf("CPU%d: System cache size %-4d MB\n", 0, statVal);
1796	}
1797
1798	rc = guest->GetStatistic(0, GuestStatisticType_PageFileSize, &statVal);
1799	if (SUCCEEDED(rc))
1800	{
1801	if (details == VMINFO_MACHINEREADABLE)
1802	RTPrintf("StatGuestPageFileSizeCPU%d=%d\n", 0, statVal);
1803	else
1804	RTPrintf("CPU%d: Page file size %-4d MB\n", 0, statVal);
1805	}
1806
1807	RTPrintf("\n");
1808	}
1809	else
1810	{
1811	if (details != VMINFO_MACHINEREADABLE)
1812	{
1813	RTPrintf("[!] FAILED calling console->getGuest at line %d!\n", __LINE__);
1814	GluePrintRCMessage(rc);
1815	}
1816	}
1817	}
1818
1819	/*
1820	* snapshots
1821	*/
1822	ComPtr<ISnapshot> snapshot;
1823	rc = machine->GetSnapshot(Guid(), snapshot.asOutParam());
1824	if (SUCCEEDED(rc) && snapshot)
1825	{
1826	if (details != VMINFO_MACHINEREADABLE)
1827	RTPrintf("Snapshots:\n\n");
1828	showSnapshots(snapshot, details);
1829	}
1830
1831	if (details != VMINFO_MACHINEREADABLE)
1832	RTPrintf("\n");
1833	return S_OK;
1834	}
1835
1836	#if defined(_MSC_VER)
1837	# pragma optimize("", on)
1838	#endif
1839
1840	int handleShowVMInfo(HandlerArg *a)
1841	{
1842	HRESULT rc;
1843
1844	/* at least one option: the UUID or name of the VM */
1845	if (a->argc < 1)
1846	return errorSyntax(USAGE_SHOWVMINFO, "Incorrect number of parameters");
1847
1848	/* try to find the given machine */
1849	ComPtr <IMachine> machine;
1850	Guid uuid (a->argv[0]);
1851	if (!uuid.isEmpty())
1852	{
1853	CHECK_ERROR (a->virtualBox, GetMachine (uuid, machine.asOutParam()));
1854	}
1855	else
1856	{
1857	CHECK_ERROR (a->virtualBox, FindMachine (Bstr(a->argv[0]), machine.asOutParam()));
1858	if (SUCCEEDED (rc))
1859	machine->COMGETTER(Id) (uuid.asOutParam());
1860	}
1861	if (FAILED (rc))
1862	return 1;
1863
1864	/* 2nd option can be -details, -statistics or -argdump */
1865	VMINFO_DETAILS details = VMINFO_NONE;
1866	bool fDetails = false;
1867	bool fStatistics = false;
1868	bool fMachinereadable = false;
1869	for (int i=1;i<a->argc;i++)
1870	{
1871	if (!strcmp(a->argv[i], "-details"))
1872	fDetails = true;
1873	else
1874	if (!strcmp(a->argv[i], "-statistics"))
1875	fStatistics = true;
1876	if (!strcmp(a->argv[1], "-machinereadable"))
1877	fMachinereadable = true;
1878	}
1879	if (fMachinereadable)
1880	details = VMINFO_MACHINEREADABLE;
1881	else
1882	if (fDetails && fStatistics)
1883	details = VMINFO_FULL;
1884	else
1885	if (fDetails)
1886	details = VMINFO_STANDARD;
1887	else
1888	if (fStatistics)
1889	details = VMINFO_STATISTICS;
1890
1891	ComPtr <IConsole> console;
1892
1893	/* open an existing session for the VM */
1894	rc = a->virtualBox->OpenExistingSession (a->session, uuid);
1895	if (SUCCEEDED(rc))
1896	/* get the session machine */
1897	rc = a->session->COMGETTER(Machine)(machine.asOutParam());
1898	if (SUCCEEDED(rc))
1899	/* get the session console */
1900	rc = a->session->COMGETTER(Console)(console.asOutParam());
1901
1902	rc = showVMInfo(a->virtualBox, machine, details, console);
1903
1904	if (console)
1905	a->session->Close();
1906
1907	return SUCCEEDED (rc) ? 0 : 1;
1908	}
1909
1910	#endif /* !VBOX_ONLY_DOCS */
1911	/* 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@ 18131

Download in other formats: