VBoxManageInfo.cpp@ 18769

Last change on this file since 18769 was 18591, checked in by vboxsync, 16 years ago
E1000: Added support for 82545EM (MT Server)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.3 KB

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

Download in other formats: