VBoxManageList.cpp@ 73716

Last change on this file since 73716 was 73716, checked in by vboxsync, 7 years ago
Main/CloudProviderManager+CloudProvider+CloudProfile: Introduce CloudProfile as separate interface, and do a big cleanup. Adding synchronization and incomplete support for moving to an extension pack. Updated VBoxManage to list providers and touched up the GUI code slightly to deal with the changed interfaces.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 60.4 KB

Line
1	/* $Id: VBoxManageList.cpp 73716 2018-08-16 15:58:57Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'list' command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.215389.xyz. 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
18	#ifndef VBOX_ONLY_DOCS
19
20
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#include <VBox/com/com.h>
25	#include <VBox/com/string.h>
26	#include <VBox/com/Guid.h>
27	#include <VBox/com/array.h>
28	#include <VBox/com/ErrorInfo.h>
29	#include <VBox/com/errorprint.h>
30
31	#include <VBox/com/VirtualBox.h>
32
33	#include <VBox/log.h>
34	#include <iprt/stream.h>
35	#include <iprt/string.h>
36	#include <iprt/time.h>
37	#include <iprt/getopt.h>
38	#include <iprt/ctype.h>
39
40	#include <vector>
41	#include <algorithm>
42
43	#include "VBoxManage.h"
44	using namespace com;
45
46	#ifdef VBOX_WITH_HOSTNETIF_API
47	static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
48	{
49	switch (enmType)
50	{
51	case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
52	case HostNetworkInterfaceMediumType_PPP: return "PPP";
53	case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
54	case HostNetworkInterfaceMediumType_Unknown: return "Unknown";
55	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
56	case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
57	#endif
58	}
59	return "unknown";
60	}
61
62	static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus)
63	{
64	switch (enmStatus)
65	{
66	case HostNetworkInterfaceStatus_Up: return "Up";
67	case HostNetworkInterfaceStatus_Down: return "Down";
68	case HostNetworkInterfaceStatus_Unknown: return "Unknown";
69	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
70	case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
71	#endif
72	}
73	return "unknown";
74	}
75	#endif /* VBOX_WITH_HOSTNETIF_API */
76
77	static const char*getDeviceTypeText(DeviceType_T enmType)
78	{
79	switch (enmType)
80	{
81	case DeviceType_HardDisk: return "HardDisk";
82	case DeviceType_DVD: return "DVD";
83	case DeviceType_Floppy: return "Floppy";
84	/* Make MSC happy */
85	case DeviceType_Null: return "Null";
86	case DeviceType_Network: return "Network";
87	case DeviceType_USB: return "USB";
88	case DeviceType_SharedFolder: return "SharedFolder";
89	case DeviceType_Graphics3D: return "Graphics3D";
90	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
91	case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
92	#endif
93	}
94	return "Unknown";
95	}
96
97
98	/**
99	* List internal networks.
100	*
101	* @returns See produceList.
102	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
103	*/
104	static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox)
105	{
106	HRESULT rc;
107	com::SafeArray<BSTR> internalNetworks;
108	CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
109	for (size_t i = 0; i < internalNetworks.size(); ++i)
110	{
111	RTPrintf("Name: %ls\n", internalNetworks[i]);
112	}
113	return rc;
114	}
115
116
117	/**
118	* List network interfaces information (bridged/host only).
119	*
120	* @returns See produceList.
121	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
122	* @param fIsBridged Selects between listing host interfaces (for
123	* use with bridging) or host only interfaces.
124	*/
125	static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox,
126	bool fIsBridged)
127	{
128	HRESULT rc;
129	ComPtr<IHost> host;
130	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
131	com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
132	#if defined(VBOX_WITH_NETFLT)
133	if (fIsBridged)
134	CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged,
135	ComSafeArrayAsOutParam(hostNetworkInterfaces)));
136	else
137	CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly,
138	ComSafeArrayAsOutParam(hostNetworkInterfaces)));
139	#else
140	RT_NOREF(fIsBridged);
141	CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
142	#endif
143	for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
144	{
145	ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i];
146	#ifndef VBOX_WITH_HOSTNETIF_API
147	Bstr interfaceName;
148	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
149	RTPrintf("Name: %ls\n", interfaceName.raw());
150	Guid interfaceGuid;
151	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
152	RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
153	#else /* VBOX_WITH_HOSTNETIF_API */
154	Bstr interfaceName;
155	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
156	RTPrintf("Name: %ls\n", interfaceName.raw());
157	Bstr interfaceGuid;
158	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
159	RTPrintf("GUID: %ls\n", interfaceGuid.raw());
160	BOOL bDHCPEnabled;
161	networkInterface->COMGETTER(DHCPEnabled)(&bDHCPEnabled);
162	RTPrintf("DHCP: %s\n", bDHCPEnabled ? "Enabled" : "Disabled");
163
164	Bstr IPAddress;
165	networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
166	RTPrintf("IPAddress: %ls\n", IPAddress.raw());
167	Bstr NetworkMask;
168	networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
169	RTPrintf("NetworkMask: %ls\n", NetworkMask.raw());
170	Bstr IPV6Address;
171	networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
172	RTPrintf("IPV6Address: %ls\n", IPV6Address.raw());
173	ULONG IPV6NetworkMaskPrefixLength;
174	networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
175	RTPrintf("IPV6NetworkMaskPrefixLength: %d\n", IPV6NetworkMaskPrefixLength);
176	Bstr HardwareAddress;
177	networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
178	RTPrintf("HardwareAddress: %ls\n", HardwareAddress.raw());
179	HostNetworkInterfaceMediumType_T Type;
180	networkInterface->COMGETTER(MediumType)(&Type);
181	RTPrintf("MediumType: %s\n", getHostIfMediumTypeText(Type));
182	BOOL fWireless;
183	networkInterface->COMGETTER(Wireless)(&fWireless);
184	RTPrintf("Wireless: %s\n", fWireless ? "Yes" : "No");
185	HostNetworkInterfaceStatus_T Status;
186	networkInterface->COMGETTER(Status)(&Status);
187	RTPrintf("Status: %s\n", getHostIfStatusText(Status));
188	Bstr netName;
189	networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
190	RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
191	#endif
192	}
193	return rc;
194	}
195
196
197	/**
198	* List host information.
199	*
200	* @returns See produceList.
201	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
202	*/
203	static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox)
204	{
205	static struct
206	{
207	ProcessorFeature_T feature;
208	const char *pszName;
209	} features[]
210	=
211	{
212	{ ProcessorFeature_HWVirtEx, "HW virtualization" },
213	{ ProcessorFeature_PAE, "PAE" },
214	{ ProcessorFeature_LongMode, "long mode" },
215	{ ProcessorFeature_NestedPaging, "nested paging" },
216	};
217	HRESULT rc;
218	ComPtr<IHost> Host;
219	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
220
221	RTPrintf("Host Information:\n\n");
222
223	LONG64 u64UtcTime = 0;
224	CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
225	RTTIMESPEC timeSpec;
226	char szTime[32];
227	RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
228
229	ULONG processorOnlineCount = 0;
230	CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
231	RTPrintf("Processor online count: %lu\n", processorOnlineCount);
232	ULONG processorCount = 0;
233	CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
234	RTPrintf("Processor count: %lu\n", processorCount);
235	ULONG processorOnlineCoreCount = 0;
236	CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
237	RTPrintf("Processor online core count: %lu\n", processorOnlineCoreCount);
238	ULONG processorCoreCount = 0;
239	CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
240	RTPrintf("Processor core count: %lu\n", processorCoreCount);
241	for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
242	{
243	BOOL supported;
244	CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
245	RTPrintf("Processor supports %s: %s\n", features[i].pszName, supported ? "yes" : "no");
246	}
247	for (ULONG i = 0; i < processorCount; i++)
248	{
249	ULONG processorSpeed = 0;
250	CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
251	if (processorSpeed)
252	RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
253	else
254	RTPrintf("Processor#%u speed: unknown\n", i);
255	Bstr processorDescription;
256	CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
257	RTPrintf("Processor#%u description: %ls\n", i, processorDescription.raw());
258	}
259
260	ULONG memorySize = 0;
261	CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
262	RTPrintf("Memory size: %lu MByte\n", memorySize);
263
264	ULONG memoryAvailable = 0;
265	CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
266	RTPrintf("Memory available: %lu MByte\n", memoryAvailable);
267
268	Bstr operatingSystem;
269	CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
270	RTPrintf("Operating system: %ls\n", operatingSystem.raw());
271
272	Bstr oSVersion;
273	CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
274	RTPrintf("Operating system version: %ls\n", oSVersion.raw());
275	return rc;
276	}
277
278
279	/**
280	* List media information.
281	*
282	* @returns See produceList.
283	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
284	* @param aMedia Medium objects to list information for.
285	* @param pszParentUUIDStr String with the parent UUID string (or "base").
286	* @param fOptLong Long (@c true) or short list format.
287	*/
288	static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
289	const com::SafeIfaceArray<IMedium> &aMedia,
290	const char *pszParentUUIDStr,
291	bool fOptLong)
292	{
293	HRESULT rc = S_OK;
294	for (size_t i = 0; i < aMedia.size(); ++i)
295	{
296	ComPtr<IMedium> pMedium = aMedia[i];
297
298	rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
299
300	RTPrintf("\n");
301
302	com::SafeIfaceArray<IMedium> children;
303	CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
304	if (children.size() > 0)
305	{
306	Bstr uuid;
307	pMedium->COMGETTER(Id)(uuid.asOutParam());
308
309	// depth first listing of child media
310	rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
311	}
312	}
313
314	return rc;
315	}
316
317
318	/**
319	* List virtual image backends.
320	*
321	* @returns See produceList.
322	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
323	*/
324	static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox)
325	{
326	HRESULT rc;
327	ComPtr<ISystemProperties> systemProperties;
328	CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
329	com::SafeIfaceArray<IMediumFormat> mediumFormats;
330	CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
331
332	RTPrintf("Supported hard disk backends:\n\n");
333	for (size_t i = 0; i < mediumFormats.size(); ++i)
334	{
335	/* General information */
336	Bstr id;
337	CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam()));
338
339	Bstr description;
340	CHECK_ERROR(mediumFormats[i],
341	COMGETTER(Name)(description.asOutParam()));
342
343	ULONG caps = 0;
344	com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
345	CHECK_ERROR(mediumFormats[i],
346	COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)));
347	for (ULONG j = 0; j < mediumFormatCap.size(); j++)
348	caps \|= mediumFormatCap[j];
349
350
351	RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
352	i, id.raw(), description.raw(), caps);
353
354	/* File extensions */
355	com::SafeArray<BSTR> fileExtensions;
356	com::SafeArray<DeviceType_T> deviceTypes;
357	CHECK_ERROR(mediumFormats[i],
358	DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
359	for (size_t j = 0; j < fileExtensions.size(); ++j)
360	{
361	RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
362	if (j != fileExtensions.size()-1)
363	RTPrintf(",");
364	}
365	RTPrintf("'");
366
367	/* Configuration keys */
368	com::SafeArray<BSTR> propertyNames;
369	com::SafeArray<BSTR> propertyDescriptions;
370	com::SafeArray<DataType_T> propertyTypes;
371	com::SafeArray<ULONG> propertyFlags;
372	com::SafeArray<BSTR> propertyDefaults;
373	CHECK_ERROR(mediumFormats[i],
374	DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
375	ComSafeArrayAsOutParam(propertyDescriptions),
376	ComSafeArrayAsOutParam(propertyTypes),
377	ComSafeArrayAsOutParam(propertyFlags),
378	ComSafeArrayAsOutParam(propertyDefaults)));
379
380	RTPrintf(" properties=(");
381	if (propertyNames.size() > 0)
382	{
383	for (size_t j = 0; j < propertyNames.size(); ++j)
384	{
385	RTPrintf("\n name='%ls' desc='%ls' type=",
386	Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
387	switch (propertyTypes[j])
388	{
389	case DataType_Int32: RTPrintf("int"); break;
390	case DataType_Int8: RTPrintf("byte"); break;
391	case DataType_String: RTPrintf("string"); break;
392	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
393	case DataType_32BitHack: break; /* Shut up compiler warnings. */
394	#endif
395	}
396	RTPrintf(" flags=%#04x", propertyFlags[j]);
397	RTPrintf(" default='%ls'", Bstr(propertyDefaults[j]).raw());
398	if (j != propertyNames.size()-1)
399	RTPrintf(", ");
400	}
401	}
402	RTPrintf(")\n");
403	}
404	return rc;
405	}
406
407
408	/**
409	* List USB devices attached to the host.
410	*
411	* @returns See produceList.
412	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
413	*/
414	static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox)
415	{
416	HRESULT rc;
417	ComPtr<IHost> Host;
418	CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
419
420	SafeIfaceArray<IHostUSBDevice> CollPtr;
421	CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
422
423	RTPrintf("Host USB Devices:\n\n");
424
425	if (CollPtr.size() == 0)
426	{
427	RTPrintf("<none>\n\n");
428	}
429	else
430	{
431	for (size_t i = 0; i < CollPtr.size(); ++i)
432	{
433	ComPtr<IHostUSBDevice> dev = CollPtr[i];
434
435	/* Query info. */
436	Bstr id;
437	CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1);
438	USHORT usVendorId;
439	CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1);
440	USHORT usProductId;
441	CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1);
442	USHORT bcdRevision;
443	CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1);
444	USHORT usPort;
445	CHECK_ERROR_RET(dev, COMGETTER(Port)(&usPort), 1);
446	USHORT usVersion;
447	CHECK_ERROR_RET(dev, COMGETTER(Version)(&usVersion), 1);
448	USHORT usPortVersion;
449	CHECK_ERROR_RET(dev, COMGETTER(PortVersion)(&usPortVersion), 1);
450	USBConnectionSpeed_T enmSpeed;
451	CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
452
453	RTPrintf("UUID: %s\n"
454	"VendorId: %#06x (%04X)\n"
455	"ProductId: %#06x (%04X)\n"
456	"Revision: %u.%u (%02u%02u)\n"
457	"Port: %u\n",
458	Utf8Str(id).c_str(),
459	usVendorId, usVendorId, usProductId, usProductId,
460	bcdRevision >> 8, bcdRevision & 0xff,
461	bcdRevision >> 8, bcdRevision & 0xff,
462	usPort);
463
464	const char *pszSpeed = "?";
465	switch (enmSpeed)
466	{
467	case USBConnectionSpeed_Low:
468	pszSpeed = "Low";
469	break;
470	case USBConnectionSpeed_Full:
471	pszSpeed = "Full";
472	break;
473	case USBConnectionSpeed_High:
474	pszSpeed = "High";
475	break;
476	case USBConnectionSpeed_Super:
477	pszSpeed = "Super";
478	break;
479	case USBConnectionSpeed_SuperPlus:
480	pszSpeed = "SuperPlus";
481	break;
482	default:
483	ASSERT(false);
484	break;
485	}
486
487	RTPrintf("USB version/speed: %u/%s\n", usVersion, pszSpeed);
488
489	/* optional stuff. */
490	SafeArray<BSTR> CollDevInfo;
491	Bstr bstr;
492	CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1);
493	if (CollDevInfo.size() >= 1)
494	bstr = Bstr(CollDevInfo[0]);
495	if (!bstr.isEmpty())
496	RTPrintf("Manufacturer: %ls\n", bstr.raw());
497	if (CollDevInfo.size() >= 2)
498	bstr = Bstr(CollDevInfo[1]);
499	if (!bstr.isEmpty())
500	RTPrintf("Product: %ls\n", bstr.raw());
501	CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
502	if (!bstr.isEmpty())
503	RTPrintf("SerialNumber: %ls\n", bstr.raw());
504	CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
505	if (!bstr.isEmpty())
506	RTPrintf("Address: %ls\n", bstr.raw());
507
508	/* current state */
509	USBDeviceState_T state;
510	CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1);
511	const char *pszState = "?";
512	switch (state)
513	{
514	case USBDeviceState_NotSupported:
515	pszState = "Not supported";
516	break;
517	case USBDeviceState_Unavailable:
518	pszState = "Unavailable";
519	break;
520	case USBDeviceState_Busy:
521	pszState = "Busy";
522	break;
523	case USBDeviceState_Available:
524	pszState = "Available";
525	break;
526	case USBDeviceState_Held:
527	pszState = "Held";
528	break;
529	case USBDeviceState_Captured:
530	pszState = "Captured";
531	break;
532	default:
533	ASSERT(false);
534	break;
535	}
536	RTPrintf("Current State: %s\n\n", pszState);
537	}
538	}
539	return rc;
540	}
541
542
543	/**
544	* List USB filters.
545	*
546	* @returns See produceList.
547	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
548	*/
549	static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox)
550	{
551	HRESULT rc;
552
553	RTPrintf("Global USB Device Filters:\n\n");
554
555	ComPtr<IHost> host;
556	CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(host.asOutParam()), 1);
557
558	SafeIfaceArray<IHostUSBDeviceFilter> coll;
559	CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1);
560
561	if (coll.size() == 0)
562	{
563	RTPrintf("<none>\n\n");
564	}
565	else
566	{
567	for (size_t index = 0; index < coll.size(); ++index)
568	{
569	ComPtr<IHostUSBDeviceFilter> flt = coll[index];
570
571	/* Query info. */
572
573	RTPrintf("Index: %zu\n", index);
574
575	BOOL active = FALSE;
576	CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
577	RTPrintf("Active: %s\n", active ? "yes" : "no");
578
579	USBDeviceFilterAction_T action;
580	CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
581	const char *pszAction = "<invalid>";
582	switch (action)
583	{
584	case USBDeviceFilterAction_Ignore:
585	pszAction = "Ignore";
586	break;
587	case USBDeviceFilterAction_Hold:
588	pszAction = "Hold";
589	break;
590	default:
591	break;
592	}
593	RTPrintf("Action: %s\n", pszAction);
594
595	Bstr bstr;
596	CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
597	RTPrintf("Name: %ls\n", bstr.raw());
598	CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
599	RTPrintf("VendorId: %ls\n", bstr.raw());
600	CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
601	RTPrintf("ProductId: %ls\n", bstr.raw());
602	CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
603	RTPrintf("Revision: %ls\n", bstr.raw());
604	CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
605	RTPrintf("Manufacturer: %ls\n", bstr.raw());
606	CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
607	RTPrintf("Product: %ls\n", bstr.raw());
608	CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
609	RTPrintf("Serial Number: %ls\n\n", bstr.raw());
610	}
611	}
612	return rc;
613	}
614
615
616	/**
617	* List system properties.
618	*
619	* @returns See produceList.
620	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
621	*/
622	static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox)
623	{
624	ComPtr<ISystemProperties> systemProperties;
625	pVirtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
626
627	Bstr str;
628	ULONG ulValue;
629	LONG64 i64Value;
630	BOOL fValue;
631	const char *psz;
632
633	pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
634	RTPrintf("API version: %ls\n", str.raw());
635
636	systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
637	RTPrintf("Minimum guest RAM size: %u Megabytes\n", ulValue);
638	systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
639	RTPrintf("Maximum guest RAM size: %u Megabytes\n", ulValue);
640	systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
641	RTPrintf("Minimum video RAM size: %u Megabytes\n", ulValue);
642	systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
643	RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue);
644	systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
645	RTPrintf("Maximum guest monitor count: %u\n", ulValue);
646	systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
647	RTPrintf("Minimum guest CPU count: %u\n", ulValue);
648	systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
649	RTPrintf("Maximum guest CPU count: %u\n", ulValue);
650	systemProperties->COMGETTER(InfoVDSize)(&i64Value);
651	RTPrintf("Virtual disk limit (info): %lld Bytes\n", i64Value);
652	systemProperties->COMGETTER(SerialPortCount)(&ulValue);
653	RTPrintf("Maximum Serial Port count: %u\n", ulValue);
654	systemProperties->COMGETTER(ParallelPortCount)(&ulValue);
655	RTPrintf("Maximum Parallel Port count: %u\n", ulValue);
656	systemProperties->COMGETTER(MaxBootPosition)(&ulValue);
657	RTPrintf("Maximum Boot Position: %u\n", ulValue);
658	systemProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue);
659	RTPrintf("Maximum PIIX3 Network Adapter count: %u\n", ulValue);
660	systemProperties->GetMaxNetworkAdapters(ChipsetType_ICH9, &ulValue);
661	RTPrintf("Maximum ICH9 Network Adapter count: %u\n", ulValue);
662	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
663	RTPrintf("Maximum PIIX3 IDE Controllers: %u\n", ulValue);
664	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
665	RTPrintf("Maximum ICH9 IDE Controllers: %u\n", ulValue);
666	systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
667	RTPrintf("Maximum IDE Port count: %u\n", ulValue);
668	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
669	RTPrintf("Maximum Devices per IDE Port: %u\n", ulValue);
670	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
671	RTPrintf("Maximum PIIX3 SATA Controllers: %u\n", ulValue);
672	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
673	RTPrintf("Maximum ICH9 SATA Controllers: %u\n", ulValue);
674	systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
675	RTPrintf("Maximum SATA Port count: %u\n", ulValue);
676	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
677	RTPrintf("Maximum Devices per SATA Port: %u\n", ulValue);
678	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
679	RTPrintf("Maximum PIIX3 SCSI Controllers: %u\n", ulValue);
680	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
681	RTPrintf("Maximum ICH9 SCSI Controllers: %u\n", ulValue);
682	systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
683	RTPrintf("Maximum SCSI Port count: %u\n", ulValue);
684	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
685	RTPrintf("Maximum Devices per SCSI Port: %u\n", ulValue);
686	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
687	RTPrintf("Maximum SAS PIIX3 Controllers: %u\n", ulValue);
688	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
689	RTPrintf("Maximum SAS ICH9 Controllers: %u\n", ulValue);
690	systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
691	RTPrintf("Maximum SAS Port count: %u\n", ulValue);
692	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
693	RTPrintf("Maximum Devices per SAS Port: %u\n", ulValue);
694	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue);
695	RTPrintf("Maximum NVMe PIIX3 Controllers: %u\n", ulValue);
696	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue);
697	RTPrintf("Maximum NVMe ICH9 Controllers: %u\n", ulValue);
698	systemProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
699	RTPrintf("Maximum NVMe Port count: %u\n", ulValue);
700	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
701	RTPrintf("Maximum Devices per NVMe Port: %u\n", ulValue);
702	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
703	RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue);
704	systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
705	RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue);
706	systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
707	RTPrintf("Maximum Floppy Port count: %u\n", ulValue);
708	systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
709	RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue);
710	#if 0
711	systemProperties->GetFreeDiskSpaceWarning(&i64Value);
712	RTPrintf("Free disk space warning at: %u Bytes\n", i64Value);
713	systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
714	RTPrintf("Free disk space warning at: %u %%\n", ulValue);
715	systemProperties->GetFreeDiskSpaceError(&i64Value);
716	RTPrintf("Free disk space error at: %u Bytes\n", i64Value);
717	systemProperties->GetFreeDiskSpacePercentError(&ulValue);
718	RTPrintf("Free disk space error at: %u %%\n", ulValue);
719	#endif
720	systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
721	RTPrintf("Default machine folder: %ls\n", str.raw());
722	systemProperties->COMGETTER(RawModeSupported)(&fValue);
723	RTPrintf("Raw-mode Supported: %s\n", fValue ? "yes" : "no");
724	systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
725	RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off");
726	systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
727	RTPrintf("Default hard disk format: %ls\n", str.raw());
728	systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
729	RTPrintf("VRDE auth library: %ls\n", str.raw());
730	systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
731	RTPrintf("Webservice auth. library: %ls\n", str.raw());
732	systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
733	RTPrintf("Remote desktop ExtPack: %ls\n", str.raw());
734	systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
735	RTPrintf("Log history count: %u\n", ulValue);
736	systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
737	RTPrintf("Default frontend: %ls\n", str.raw());
738	AudioDriverType_T enmAudio;
739	systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
740	switch (enmAudio)
741	{
742	case AudioDriverType_Null: psz = "Null"; break;
743	case AudioDriverType_WinMM: psz = "WinMM"; break;
744	case AudioDriverType_OSS: psz = "OSS"; break;
745	case AudioDriverType_ALSA: psz = "ALSA"; break;
746	case AudioDriverType_DirectSound: psz = "DirectSound"; break;
747	case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
748	case AudioDriverType_MMPM: psz = "MMPM"; break;
749	case AudioDriverType_Pulse: psz = "Pulse"; break;
750	case AudioDriverType_SolAudio: psz = "SolAudio"; break;
751	default: psz = "Unknown";
752	}
753	RTPrintf("Default audio driver: %s\n", psz);
754	systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
755	RTPrintf("Autostart database path: %ls\n", str.raw());
756	systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
757	RTPrintf("Default Guest Additions ISO: %ls\n", str.raw());
758	systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
759	RTPrintf("Logging Level: %ls\n", str.raw());
760	return S_OK;
761	}
762
763
764	/**
765	* List extension packs.
766	*
767	* @returns See produceList.
768	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
769	*/
770	static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
771	{
772	ComObjPtr<IExtPackManager> ptrExtPackMgr;
773	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
774
775	SafeIfaceArray<IExtPack> extPacks;
776	CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
777	RTPrintf("Extension Packs: %u\n", extPacks.size());
778
779	HRESULT hrc = S_OK;
780	for (size_t i = 0; i < extPacks.size(); i++)
781	{
782	/* Read all the properties. */
783	Bstr bstrName;
784	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
785	Bstr bstrDesc;
786	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
787	Bstr bstrVersion;
788	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
789	ULONG uRevision;
790	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
791	Bstr bstrEdition;
792	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
793	Bstr bstrVrdeModule;
794	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
795	BOOL fUsable;
796	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
797	Bstr bstrWhy;
798	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
799
800	/* Display them. */
801	if (i)
802	RTPrintf("\n");
803	RTPrintf("Pack no.%2zu: %ls\n"
804	"Version: %ls\n"
805	"Revision: %u\n"
806	"Edition: %ls\n"
807	"Description: %ls\n"
808	"VRDE Module: %ls\n"
809	"Usable: %RTbool\n"
810	"Why unusable: %ls\n",
811	i, bstrName.raw(),
812	bstrVersion.raw(),
813	uRevision,
814	bstrEdition.raw(),
815	bstrDesc.raw(),
816	bstrVrdeModule.raw(),
817	fUsable != FALSE,
818	bstrWhy.raw());
819
820	/* Query plugins and display them. */
821	}
822	return hrc;
823	}
824
825
826	/**
827	* List machine groups.
828	*
829	* @returns See produceList.
830	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
831	*/
832	static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
833	{
834	SafeArray<BSTR> groups;
835	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
836
837	for (size_t i = 0; i < groups.size(); i++)
838	{
839	RTPrintf("\"%ls\"\n", groups[i]);
840	}
841	return S_OK;
842	}
843
844
845	/**
846	* List video capture devices.
847	*
848	* @returns See produceList.
849	* @param pVirtualBox Reference to the IVirtualBox pointer.
850	*/
851	static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox)
852	{
853	HRESULT rc;
854	ComPtr<IHost> host;
855	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
856	com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
857	CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
858	RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size());
859	for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
860	{
861	ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
862	Bstr name;
863	p->COMGETTER(Name)(name.asOutParam());
864	Bstr path;
865	p->COMGETTER(Path)(path.asOutParam());
866	Bstr alias;
867	p->COMGETTER(Alias)(alias.asOutParam());
868	RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
869	}
870	return rc;
871	}
872
873	/**
874	* List supported screen shot formats.
875	*
876	* @returns See produceList.
877	* @param pVirtualBox Reference to the IVirtualBox pointer.
878	*/
879	static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> pVirtualBox)
880	{
881	HRESULT rc = S_OK;
882	ComPtr<ISystemProperties> systemProperties;
883	CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
884	com::SafeArray<BitmapFormat_T> formats;
885	CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
886
887	RTPrintf("Supported %d screen shot formats:\n", formats.size());
888	for (size_t i = 0; i < formats.size(); ++i)
889	{
890	uint32_t u32Format = (uint32_t)formats[i];
891	char szFormat[5];
892	szFormat[0] = RT_BYTE1(u32Format);
893	szFormat[1] = RT_BYTE2(u32Format);
894	szFormat[2] = RT_BYTE3(u32Format);
895	szFormat[3] = RT_BYTE4(u32Format);
896	szFormat[4] = 0;
897	RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
898	}
899	return rc;
900	}
901
902	/**
903	* List available cloud providers.
904	*
905	* @returns See produceList.
906	* @param pVirtualBox Reference to the IVirtualBox pointer.
907	*/
908	static HRESULT listCloudProviders(const ComPtr<IVirtualBox> pVirtualBox)
909	{
910	HRESULT rc = S_OK;
911	ComPtr<ICloudProviderManager> pCloudProviderManager;
912	CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
913	com::SafeIfaceArray<ICloudProvider> apCloudProviders;
914	CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
915
916	RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size());
917	for (size_t i = 0; i < apCloudProviders.size(); ++i)
918	{
919	ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
920	Bstr bstrProviderName;
921	pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
922	RTPrintf("Name: %ls\n", bstrProviderName.raw());
923	pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
924	RTPrintf("Short Name: %ls\n", bstrProviderName.raw());
925	Bstr bstrProviderID;
926	pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
927	RTPrintf("GUID: %ls\n", bstrProviderID.raw());
928
929	RTPrintf("\n");
930	}
931	return rc;
932	}
933
934
935	/**
936	* List all available cloud profiles (by iterating over the cloud providers).
937	*
938	* @returns See produceList.
939	* @param pVirtualBox Reference to the IVirtualBox pointer.
940	* @param fOptLong If true, list all profile properties.
941	*/
942	static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
943	{
944	HRESULT rc = S_OK;
945	ComPtr<ICloudProviderManager> pCloudProviderManager;
946	CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
947	com::SafeIfaceArray<ICloudProvider> apCloudProviders;
948	CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
949
950	for (size_t i = 0; i < apCloudProviders.size(); ++i)
951	{
952	ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
953	com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
954	CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
955	for (size_t j = 0; j < apCloudProfiles.size(); ++j)
956	{
957	ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
958	Bstr bstrProfileName;
959	pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
960	RTPrintf("Name: %ls\n", bstrProfileName.raw());
961	Bstr bstrProviderID;
962	pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
963	RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
964
965	if (fOptLong)
966	{
967	com::SafeArray<BSTR> names;
968	com::SafeArray<BSTR> values;
969	pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
970	size_t cNames = names.size();
971	size_t cValues = values.size();
972	bool fFirst = true;
973	for (size_t k = 0; k < cNames; k++)
974	{
975	Bstr value;
976	if (k < cValues)
977	value = values[k];
978	RTPrintf("%s%ls=%ls\n",
979	fFirst ? "Property: " : " ",
980	names[k], value.raw());
981	fFirst = false;
982	}
983	}
984
985	RTPrintf("\n");
986	}
987	}
988	return rc;
989	}
990
991
992	/**
993	* The type of lists we can produce.
994	*/
995	enum enmListType
996	{
997	kListNotSpecified = 1000,
998	kListVMs,
999	kListRunningVMs,
1000	kListOsTypes,
1001	kListHostDvds,
1002	kListHostFloppies,
1003	kListInternalNetworks,
1004	kListBridgedInterfaces,
1005	#if defined(VBOX_WITH_NETFLT)
1006	kListHostOnlyInterfaces,
1007	#endif
1008	kListHostCpuIDs,
1009	kListHostInfo,
1010	kListHddBackends,
1011	kListHdds,
1012	kListDvds,
1013	kListFloppies,
1014	kListUsbHost,
1015	kListUsbFilters,
1016	kListSystemProperties,
1017	kListDhcpServers,
1018	kListExtPacks,
1019	kListGroups,
1020	kListNatNetworks,
1021	kListVideoInputDevices,
1022	kListScreenShotFormats,
1023	kListCloudProviders,
1024	kListCloudProfiles,
1025	};
1026
1027
1028	/**
1029	* Produces the specified listing.
1030	*
1031	* @returns S_OK or some COM error code that has been reported in full.
1032	* @param enmList The list to produce.
1033	* @param fOptLong Long (@c true) or short list format.
1034	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
1035	*/
1036	static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
1037	{
1038	HRESULT rc = S_OK;
1039	switch (enmCommand)
1040	{
1041	case kListNotSpecified:
1042	AssertFailed();
1043	return E_FAIL;
1044
1045	case kListVMs:
1046	{
1047	/*
1048	* Get the list of all registered VMs
1049	*/
1050	com::SafeIfaceArray<IMachine> machines;
1051	rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1052	if (SUCCEEDED(rc))
1053	{
1054	/*
1055	* Display it.
1056	*/
1057	if (!fOptSorted)
1058	{
1059	for (size_t i = 0; i < machines.size(); ++i)
1060	if (machines[i])
1061	rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1062	}
1063	else
1064	{
1065	/*
1066	* Sort the list by name before displaying it.
1067	*/
1068	std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
1069	for (size_t i = 0; i < machines.size(); ++i)
1070	{
1071	IMachine *pMachine = machines[i];
1072	if (pMachine) /* no idea why we need to do this... */
1073	{
1074	Bstr bstrName;
1075	pMachine->COMGETTER(Name)(bstrName.asOutParam());
1076	sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
1077	}
1078	}
1079
1080	std::sort(sortedMachines.begin(), sortedMachines.end());
1081
1082	for (size_t i = 0; i < sortedMachines.size(); ++i)
1083	rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1084	}
1085	}
1086	break;
1087	}
1088
1089	case kListRunningVMs:
1090	{
1091	/*
1092	* Get the list of all _running_ VMs
1093	*/
1094	com::SafeIfaceArray<IMachine> machines;
1095	rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1096	com::SafeArray<MachineState_T> states;
1097	if (SUCCEEDED(rc))
1098	rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
1099	if (SUCCEEDED(rc))
1100	{
1101	/*
1102	* Iterate through the collection
1103	*/
1104	for (size_t i = 0; i < machines.size(); ++i)
1105	{
1106	if (machines[i])
1107	{
1108	MachineState_T machineState = states[i];
1109	switch (machineState)
1110	{
1111	case MachineState_Running:
1112	case MachineState_Teleporting:
1113	case MachineState_LiveSnapshotting:
1114	case MachineState_Paused:
1115	case MachineState_TeleportingPausedVM:
1116	rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1117	break;
1118	default: break; /* Shut up MSC */
1119	}
1120	}
1121	}
1122	}
1123	break;
1124	}
1125
1126	case kListOsTypes:
1127	{
1128	com::SafeIfaceArray<IGuestOSType> coll;
1129	rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
1130	if (SUCCEEDED(rc))
1131	{
1132	/*
1133	* Iterate through the collection.
1134	*/
1135	for (size_t i = 0; i < coll.size(); ++i)
1136	{
1137	ComPtr<IGuestOSType> guestOS;
1138	guestOS = coll[i];
1139	Bstr guestId;
1140	guestOS->COMGETTER(Id)(guestId.asOutParam());
1141	RTPrintf("ID: %ls\n", guestId.raw());
1142	Bstr guestDescription;
1143	guestOS->COMGETTER(Description)(guestDescription.asOutParam());
1144	RTPrintf("Description: %ls\n", guestDescription.raw());
1145	Bstr familyId;
1146	guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
1147	RTPrintf("Family ID: %ls\n", familyId.raw());
1148	Bstr familyDescription;
1149	guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
1150	RTPrintf("Family Desc: %ls\n", familyDescription.raw());
1151	BOOL is64Bit;
1152	guestOS->COMGETTER(Is64Bit)(&is64Bit);
1153	RTPrintf("64 bit: %RTbool\n", is64Bit);
1154	RTPrintf("\n");
1155	}
1156	}
1157	break;
1158	}
1159
1160	case kListHostDvds:
1161	{
1162	ComPtr<IHost> host;
1163	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1164	com::SafeIfaceArray<IMedium> coll;
1165	CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
1166	if (SUCCEEDED(rc))
1167	{
1168	for (size_t i = 0; i < coll.size(); ++i)
1169	{
1170	ComPtr<IMedium> dvdDrive = coll[i];
1171	Bstr uuid;
1172	dvdDrive->COMGETTER(Id)(uuid.asOutParam());
1173	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1174	Bstr location;
1175	dvdDrive->COMGETTER(Location)(location.asOutParam());
1176	RTPrintf("Name: %ls\n\n", location.raw());
1177	}
1178	}
1179	break;
1180	}
1181
1182	case kListHostFloppies:
1183	{
1184	ComPtr<IHost> host;
1185	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1186	com::SafeIfaceArray<IMedium> coll;
1187	CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
1188	if (SUCCEEDED(rc))
1189	{
1190	for (size_t i = 0; i < coll.size(); ++i)
1191	{
1192	ComPtr<IMedium> floppyDrive = coll[i];
1193	Bstr uuid;
1194	floppyDrive->COMGETTER(Id)(uuid.asOutParam());
1195	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1196	Bstr location;
1197	floppyDrive->COMGETTER(Location)(location.asOutParam());
1198	RTPrintf("Name: %ls\n\n", location.raw());
1199	}
1200	}
1201	break;
1202	}
1203
1204	case kListInternalNetworks:
1205	rc = listInternalNetworks(pVirtualBox);
1206	break;
1207
1208	case kListBridgedInterfaces:
1209	#if defined(VBOX_WITH_NETFLT)
1210	case kListHostOnlyInterfaces:
1211	#endif
1212	rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
1213	break;
1214
1215	case kListHostInfo:
1216	rc = listHostInfo(pVirtualBox);
1217	break;
1218
1219	case kListHostCpuIDs:
1220	{
1221	ComPtr<IHost> Host;
1222	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
1223
1224	RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
1225	ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
1226	static uint32_t const s_auCpuIdRanges[] =
1227	{
1228	UINT32_C(0x00000000), UINT32_C(0x0000007f),
1229	UINT32_C(0x80000000), UINT32_C(0x8000007f),
1230	UINT32_C(0xc0000000), UINT32_C(0xc000007f)
1231	};
1232	for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
1233	{
1234	ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
1235	CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
1236	if (cLeafs < s_auCpuIdRanges[i] \|\| cLeafs > s_auCpuIdRanges[i+1])
1237	continue;
1238	cLeafs++;
1239	for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
1240	{
1241	CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
1242	RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
1243	}
1244	}
1245	break;
1246	}
1247
1248	case kListHddBackends:
1249	rc = listHddBackends(pVirtualBox);
1250	break;
1251
1252	case kListHdds:
1253	{
1254	com::SafeIfaceArray<IMedium> hdds;
1255	CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
1256	rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
1257	break;
1258	}
1259
1260	case kListDvds:
1261	{
1262	com::SafeIfaceArray<IMedium> dvds;
1263	CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
1264	rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
1265	break;
1266	}
1267
1268	case kListFloppies:
1269	{
1270	com::SafeIfaceArray<IMedium> floppies;
1271	CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
1272	rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
1273	break;
1274	}
1275
1276	case kListUsbHost:
1277	rc = listUsbHost(pVirtualBox);
1278	break;
1279
1280	case kListUsbFilters:
1281	rc = listUsbFilters(pVirtualBox);
1282	break;
1283
1284	case kListSystemProperties:
1285	rc = listSystemProperties(pVirtualBox);
1286	break;
1287
1288	case kListDhcpServers:
1289	{
1290	com::SafeIfaceArray<IDHCPServer> svrs;
1291	CHECK_ERROR(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)));
1292	for (size_t i = 0; i < svrs.size(); ++i)
1293	{
1294	ComPtr<IDHCPServer> svr = svrs[i];
1295	Bstr netName;
1296	svr->COMGETTER(NetworkName)(netName.asOutParam());
1297	RTPrintf("NetworkName: %ls\n", netName.raw());
1298	Bstr ip;
1299	svr->COMGETTER(IPAddress)(ip.asOutParam());
1300	RTPrintf("IP: %ls\n", ip.raw());
1301	Bstr netmask;
1302	svr->COMGETTER(NetworkMask)(netmask.asOutParam());
1303	RTPrintf("NetworkMask: %ls\n", netmask.raw());
1304	Bstr lowerIp;
1305	svr->COMGETTER(LowerIP)(lowerIp.asOutParam());
1306	RTPrintf("lowerIPAddress: %ls\n", lowerIp.raw());
1307	Bstr upperIp;
1308	svr->COMGETTER(UpperIP)(upperIp.asOutParam());
1309	RTPrintf("upperIPAddress: %ls\n", upperIp.raw());
1310	BOOL fEnabled;
1311	svr->COMGETTER(Enabled)(&fEnabled);
1312	RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1313	RTPrintf("\n");
1314	}
1315	break;
1316	}
1317
1318	case kListExtPacks:
1319	rc = listExtensionPacks(pVirtualBox);
1320	break;
1321
1322	case kListGroups:
1323	rc = listGroups(pVirtualBox);
1324	break;
1325
1326	case kListNatNetworks:
1327	{
1328	com::SafeIfaceArray<INATNetwork> nets;
1329	CHECK_ERROR(pVirtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nets)));
1330	for (size_t i = 0; i < nets.size(); ++i)
1331	{
1332	ComPtr<INATNetwork> net = nets[i];
1333	Bstr netName;
1334	net->COMGETTER(NetworkName)(netName.asOutParam());
1335	RTPrintf("NetworkName: %ls\n", netName.raw());
1336	Bstr gateway;
1337	net->COMGETTER(Gateway)(gateway.asOutParam());
1338	RTPrintf("IP: %ls\n", gateway.raw());
1339	Bstr network;
1340	net->COMGETTER(Network)(network.asOutParam());
1341	RTPrintf("Network: %ls\n", network.raw());
1342	BOOL fEnabled;
1343	net->COMGETTER(IPv6Enabled)(&fEnabled);
1344	RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No");
1345	Bstr ipv6prefix;
1346	net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
1347	RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw());
1348	net->COMGETTER(NeedDhcpServer)(&fEnabled);
1349	RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No");
1350	net->COMGETTER(Enabled)(&fEnabled);
1351	RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1352
1353	#define PRINT_STRING_ARRAY(title) \
1354	if (strs.size() > 0) \
1355	{ \
1356	RTPrintf(title); \
1357	size_t j = 0; \
1358	for (;j < strs.size(); ++j) \
1359	RTPrintf(" %s\n", Utf8Str(strs[j]).c_str()); \
1360	}
1361
1362	com::SafeArray<BSTR> strs;
1363
1364	CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs)));
1365	PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n");
1366	strs.setNull();
1367
1368	CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs)));
1369	PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n");
1370	strs.setNull();
1371
1372	CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs)));
1373	PRINT_STRING_ARRAY("loopback mappings (ipv4)\n");
1374	strs.setNull();
1375
1376	#undef PRINT_STRING_ARRAY
1377	RTPrintf("\n");
1378	}
1379	break;
1380	}
1381
1382	case kListVideoInputDevices:
1383	rc = listVideoInputDevices(pVirtualBox);
1384	break;
1385
1386	case kListScreenShotFormats:
1387	rc = listScreenShotFormats(pVirtualBox);
1388	break;
1389
1390	case kListCloudProviders:
1391	rc = listCloudProviders(pVirtualBox);
1392	break;
1393
1394	case kListCloudProfiles:
1395	rc = listCloudProfiles(pVirtualBox, fOptLong);
1396	break;
1397
1398	/* No default here, want gcc warnings. */
1399
1400	} /* end switch */
1401
1402	return rc;
1403	}
1404
1405	/**
1406	* Handles the 'list' command.
1407	*
1408	* @returns Appropriate exit code.
1409	* @param a Handler argument.
1410	*/
1411	RTEXITCODE handleList(HandlerArg *a)
1412	{
1413	bool fOptLong = false;
1414	bool fOptMultiple = false;
1415	bool fOptSorted = false;
1416	enum enmListType enmOptCommand = kListNotSpecified;
1417
1418	static const RTGETOPTDEF s_aListOptions[] =
1419	{
1420	{ "--long", 'l', RTGETOPT_REQ_NOTHING },
1421	{ "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
1422	{ "--sorted", 's', RTGETOPT_REQ_NOTHING },
1423	{ "vms", kListVMs, RTGETOPT_REQ_NOTHING },
1424	{ "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
1425	{ "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
1426	{ "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
1427	{ "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
1428	{ "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
1429	{ "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
1430	{ "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
1431	#if defined(VBOX_WITH_NETFLT)
1432	{ "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
1433	#endif
1434	{ "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1435	{ "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1436	{ "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
1437	{ "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
1438	{ "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
1439	{ "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
1440	{ "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
1441	{ "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
1442	{ "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
1443	{ "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
1444	{ "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
1445	{ "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
1446	{ "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
1447	{ "groups", kListGroups, RTGETOPT_REQ_NOTHING },
1448	{ "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
1449	{ "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
1450	{ "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
1451	{ "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
1452	};
1453
1454	int ch;
1455	RTGETOPTUNION ValueUnion;
1456	RTGETOPTSTATE GetState;
1457	RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
1458	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1459	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1460	{
1461	switch (ch)
1462	{
1463	case 'l': /* --long */
1464	fOptLong = true;
1465	break;
1466
1467	case 's':
1468	fOptSorted = true;
1469	break;
1470
1471	case 'm':
1472	fOptMultiple = true;
1473	if (enmOptCommand == kListNotSpecified)
1474	break;
1475	ch = enmOptCommand;
1476	RT_FALL_THRU();
1477
1478	case kListVMs:
1479	case kListRunningVMs:
1480	case kListOsTypes:
1481	case kListHostDvds:
1482	case kListHostFloppies:
1483	case kListInternalNetworks:
1484	case kListBridgedInterfaces:
1485	#if defined(VBOX_WITH_NETFLT)
1486	case kListHostOnlyInterfaces:
1487	#endif
1488	case kListHostInfo:
1489	case kListHostCpuIDs:
1490	case kListHddBackends:
1491	case kListHdds:
1492	case kListDvds:
1493	case kListFloppies:
1494	case kListUsbHost:
1495	case kListUsbFilters:
1496	case kListSystemProperties:
1497	case kListDhcpServers:
1498	case kListExtPacks:
1499	case kListGroups:
1500	case kListNatNetworks:
1501	case kListVideoInputDevices:
1502	case kListScreenShotFormats:
1503	case kListCloudProviders:
1504	case kListCloudProfiles:
1505	enmOptCommand = (enum enmListType)ch;
1506	if (fOptMultiple)
1507	{
1508	HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox);
1509	if (FAILED(hrc))
1510	return RTEXITCODE_FAILURE;
1511	}
1512	break;
1513
1514	case VINF_GETOPT_NOT_OPTION:
1515	return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
1516
1517	default:
1518	return errorGetOpt(USAGE_LIST, ch, &ValueUnion);
1519	}
1520	}
1521
1522	/*
1523	* If not in multiple list mode, we have to produce the list now.
1524	*/
1525	if (enmOptCommand == kListNotSpecified)
1526	return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
1527	if (!fOptMultiple)
1528	{
1529	HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
1530	if (FAILED(hrc))
1531	return RTEXITCODE_FAILURE;
1532	}
1533
1534	return RTEXITCODE_SUCCESS;
1535	}
1536
1537	#endif /* !VBOX_ONLY_DOCS */
1538	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp@ 73716

Download in other formats: