VBoxManageInfo.cpp@ 22866

Last change on this file since 22866 was 22866, checked in by vboxsync, 16 years ago
#3987: Virtio PCI + Net skeleton.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 77.8 KB

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

Download in other formats: