VBoxManageInfo.cpp@ 17684

Last change on this file since 17684 was 17684, checked in by vboxsync, 16 years ago
#3551: “Main: Replace remaining collections with safe arrays” Replaced HostUSBDeviceCollection. Reviewed/Okayed by dmik, sunlover.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 73.7 KB

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

Download in other formats: