VBoxManageList.cpp@ 101128

Last change on this file since 101128 was 101128, checked in by vboxsync, 15 months ago
FE/VBoxManage: Improved "show systemproperties": Removed the hardcoded limitation of only showing PIIX3 chipset information, added support for dynamically showing supported platforms + their supported chipsets. Grouping of output for better readability. Needs a bit more polishing wrt uniform output (see @todo) though [Windows build fix]. bugref:10384
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 103.3 KB

Line
1	/* $Id: VBoxManageList.cpp 101128 2023-09-15 14:34:40Z vboxsync $ */
2	/** @file
3	* VBoxManage - The 'list' command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <VBox/com/com.h>
33	#include <VBox/com/string.h>
34	#include <VBox/com/Guid.h>
35	#include <VBox/com/array.h>
36	#include <VBox/com/ErrorInfo.h>
37	#include <VBox/com/errorprint.h>
38
39	#include <VBox/com/VirtualBox.h>
40
41	#include <VBox/log.h>
42	#include <iprt/stream.h>
43	#include <iprt/string.h>
44	#include <iprt/time.h>
45	#include <iprt/getopt.h>
46	#include <iprt/ctype.h>
47
48	#include <vector>
49	#include <algorithm>
50
51	#include "VBoxManage.h"
52	using namespace com;
53
54	DECLARE_TRANSLATION_CONTEXT(List);
55
56	#ifdef VBOX_WITH_HOSTNETIF_API
57	static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
58	{
59	switch (enmType)
60	{
61	case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
62	case HostNetworkInterfaceMediumType_PPP: return "PPP";
63	case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
64	case HostNetworkInterfaceMediumType_Unknown: return List::tr("Unknown");
65	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
66	case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
67	#endif
68	}
69	return List::tr("unknown");
70	}
71
72	static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus)
73	{
74	switch (enmStatus)
75	{
76	case HostNetworkInterfaceStatus_Up: return List::tr("Up");
77	case HostNetworkInterfaceStatus_Down: return List::tr("Down");
78	case HostNetworkInterfaceStatus_Unknown: return List::tr("Unknown");
79	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
80	case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
81	#endif
82	}
83	return List::tr("unknown");
84	}
85	#endif /* VBOX_WITH_HOSTNETIF_API */
86
87	static const char*getDeviceTypeText(DeviceType_T enmType)
88	{
89	switch (enmType)
90	{
91	case DeviceType_HardDisk: return List::tr("HardDisk");
92	case DeviceType_DVD: return "DVD";
93	case DeviceType_Floppy: return List::tr("Floppy");
94	/* Make MSC happy */
95	case DeviceType_Null: return "Null";
96	case DeviceType_Network: return List::tr("Network");
97	case DeviceType_USB: return "USB";
98	case DeviceType_SharedFolder: return List::tr("SharedFolder");
99	case DeviceType_Graphics3D: return List::tr("Graphics3D");
100	case DeviceType_End: break; /* Shut up compiler warnings. */
101	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
102	case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
103	#endif
104	}
105	return List::tr("Unknown");
106	}
107
108
109	/**
110	* List internal networks.
111	*
112	* @returns See produceList.
113	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
114	*/
115	static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox)
116	{
117	HRESULT hrc;
118	com::SafeArray<BSTR> internalNetworks;
119	CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
120	for (size_t i = 0; i < internalNetworks.size(); ++i)
121	{
122	RTPrintf(List::tr("Name: %ls\n"), internalNetworks[i]);
123	}
124	return hrc;
125	}
126
127
128	/**
129	* List network interfaces information (bridged/host only).
130	*
131	* @returns See produceList.
132	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
133	* @param fIsBridged Selects between listing host interfaces (for
134	* use with bridging) or host only interfaces.
135	*/
136	static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox,
137	bool fIsBridged)
138	{
139	HRESULT hrc;
140	ComPtr<IHost> host;
141	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
142	com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
143	#if defined(VBOX_WITH_NETFLT)
144	if (fIsBridged)
145	CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged,
146	ComSafeArrayAsOutParam(hostNetworkInterfaces)));
147	else
148	CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly,
149	ComSafeArrayAsOutParam(hostNetworkInterfaces)));
150	#else
151	RT_NOREF(fIsBridged);
152	CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
153	#endif
154	for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
155	{
156	ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i];
157	#ifndef VBOX_WITH_HOSTNETIF_API
158	Bstr interfaceName;
159	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
160	RTPrintf(List::tr("Name: %ls\n"), interfaceName.raw());
161	Guid interfaceGuid;
162	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
163	RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
164	#else /* VBOX_WITH_HOSTNETIF_API */
165	Bstr interfaceName;
166	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
167	RTPrintf(List::tr("Name: %ls\n"), interfaceName.raw());
168	Bstr interfaceGuid;
169	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
170	RTPrintf("GUID: %ls\n", interfaceGuid.raw());
171	BOOL fDHCPEnabled = FALSE;
172	networkInterface->COMGETTER(DHCPEnabled)(&fDHCPEnabled);
173	RTPrintf("DHCP: %s\n", fDHCPEnabled ? List::tr("Enabled") : List::tr("Disabled"));
174
175	Bstr IPAddress;
176	networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
177	RTPrintf(List::tr("IPAddress: %ls\n"), IPAddress.raw());
178	Bstr NetworkMask;
179	networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
180	RTPrintf(List::tr("NetworkMask: %ls\n"), NetworkMask.raw());
181	Bstr IPV6Address;
182	networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
183	RTPrintf(List::tr("IPV6Address: %ls\n"), IPV6Address.raw());
184	ULONG IPV6NetworkMaskPrefixLength;
185	networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
186	RTPrintf(List::tr("IPV6NetworkMaskPrefixLength: %d\n"), IPV6NetworkMaskPrefixLength);
187	Bstr HardwareAddress;
188	networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
189	RTPrintf(List::tr("HardwareAddress: %ls\n"), HardwareAddress.raw());
190	HostNetworkInterfaceMediumType_T Type;
191	networkInterface->COMGETTER(MediumType)(&Type);
192	RTPrintf(List::tr("MediumType: %s\n"), getHostIfMediumTypeText(Type));
193	BOOL fWireless = FALSE;
194	networkInterface->COMGETTER(Wireless)(&fWireless);
195	RTPrintf(List::tr("Wireless: %s\n"), fWireless ? List::tr("Yes") : List::tr("No"));
196	HostNetworkInterfaceStatus_T Status;
197	networkInterface->COMGETTER(Status)(&Status);
198	RTPrintf(List::tr("Status: %s\n"), getHostIfStatusText(Status));
199	Bstr netName;
200	networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
201	RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
202	#endif
203	}
204	return hrc;
205	}
206
207
208	#ifdef VBOX_WITH_VMNET
209	/**
210	* List configured host-only networks.
211	*
212	* @returns See produceList.
213	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
214	* @param Reserved Placeholder!
215	*/
216	static HRESULT listHostOnlyNetworks(const ComPtr<IVirtualBox> pVirtualBox)
217	{
218	HRESULT hrc;
219	com::SafeIfaceArray<IHostOnlyNetwork> hostOnlyNetworks;
220	CHECK_ERROR(pVirtualBox, COMGETTER(HostOnlyNetworks)(ComSafeArrayAsOutParam(hostOnlyNetworks)));
221	for (size_t i = 0; i < hostOnlyNetworks.size(); ++i)
222	{
223	ComPtr<IHostOnlyNetwork> hostOnlyNetwork = hostOnlyNetworks[i];
224	Bstr bstrNetworkName;
225	CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(NetworkName)(bstrNetworkName.asOutParam()));
226	RTPrintf(List::tr("Name: %ls\n"), bstrNetworkName.raw());
227
228	Bstr bstr;
229	CHECK_ERROR(hostOnlyNetwork, COMGETTER(Id)(bstr.asOutParam()));
230	RTPrintf("GUID: %ls\n\n", bstr.raw());
231
232	BOOL fEnabled = FALSE;
233	CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(Enabled)(&fEnabled));
234	RTPrintf(List::tr("State: %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
235
236	CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(NetworkMask)(bstr.asOutParam()));
237	RTPrintf(List::tr("NetworkMask: %ls\n"), bstr.raw());
238
239	CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(LowerIP)(bstr.asOutParam()));
240	RTPrintf(List::tr("LowerIP: %ls\n"), bstr.raw());
241
242	CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(UpperIP)(bstr.asOutParam()));
243	RTPrintf(List::tr("UpperIP: %ls\n"), bstr.raw());
244
245	// CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(Id)(bstr.asOutParam());
246	// RTPrintf("NetworkId: %ls\n", bstr.raw());
247
248	RTPrintf(List::tr("VBoxNetworkName: hostonly-%ls\n\n"), bstrNetworkName.raw());
249	}
250	return hrc;
251	}
252	#endif /* VBOX_WITH_VMNET */
253
254
255	#ifdef VBOX_WITH_CLOUD_NET
256	/**
257	* List configured cloud network attachments.
258	*
259	* @returns See produceList.
260	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
261	* @param Reserved Placeholder!
262	*/
263	static HRESULT listCloudNetworks(const ComPtr<IVirtualBox> pVirtualBox)
264	{
265	com::SafeIfaceArray<ICloudNetwork> cloudNetworks;
266	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(CloudNetworks)(ComSafeArrayAsOutParam(cloudNetworks)), hrcCheck);
267	for (size_t i = 0; i < cloudNetworks.size(); ++i)
268	{
269	ComPtr<ICloudNetwork> cloudNetwork = cloudNetworks[i];
270	Bstr networkName;
271	cloudNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
272	RTPrintf(List::tr("Name: %ls\n"), networkName.raw());
273	// Guid interfaceGuid;
274	// cloudNetwork->COMGETTER(Id)(interfaceGuid.asOutParam());
275	// RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
276	BOOL fEnabled = FALSE;
277	cloudNetwork->COMGETTER(Enabled)(&fEnabled);
278	RTPrintf(List::tr("State: %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
279
280	Bstr Provider;
281	cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
282	RTPrintf(List::tr("CloudProvider: %ls\n"), Provider.raw());
283	Bstr Profile;
284	cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
285	RTPrintf(List::tr("CloudProfile: %ls\n"), Profile.raw());
286	Bstr NetworkId;
287	cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
288	RTPrintf(List::tr("CloudNetworkId: %ls\n"), NetworkId.raw());
289	Bstr netName = BstrFmt("cloud-%ls", networkName.raw());
290	RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
291	}
292	return S_OK;
293	}
294	#endif /* VBOX_WITH_CLOUD_NET */
295
296
297	/**
298	* List host information.
299	*
300	* @returns See produceList.
301	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
302	*/
303	static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox)
304	{
305	static struct
306	{
307	ProcessorFeature_T feature;
308	const char *pszName;
309	} features[]
310	=
311	{
312	{ ProcessorFeature_HWVirtEx, List::tr("HW virtualization") },
313	{ ProcessorFeature_PAE, "PAE" },
314	{ ProcessorFeature_LongMode, List::tr("long mode") },
315	{ ProcessorFeature_NestedPaging, List::tr("nested paging") },
316	{ ProcessorFeature_UnrestrictedGuest, List::tr("unrestricted guest") },
317	{ ProcessorFeature_NestedHWVirt, List::tr("nested HW virtualization") },
318	{ ProcessorFeature_VirtVmsaveVmload, List::tr("virt. vmsave/vmload") },
319	};
320	HRESULT hrc;
321	ComPtr<IHost> Host;
322	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
323
324	RTPrintf(List::tr("Host Information:\n\n"));
325
326	LONG64 u64UtcTime = 0;
327	CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
328	RTTIMESPEC timeSpec;
329	char szTime[32];
330	RTPrintf(List::tr("Host time: %s\n"), RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
331
332	ULONG processorOnlineCount = 0;
333	CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
334	RTPrintf(List::tr("Processor online count: %lu\n"), processorOnlineCount);
335	ULONG processorCount = 0;
336	CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
337	RTPrintf(List::tr("Processor count: %lu\n"), processorCount);
338	ULONG processorOnlineCoreCount = 0;
339	CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
340	RTPrintf(List::tr("Processor online core count: %lu\n"), processorOnlineCoreCount);
341	ULONG processorCoreCount = 0;
342	CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
343	RTPrintf(List::tr("Processor core count: %lu\n"), processorCoreCount);
344	for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
345	{
346	BOOL supported;
347	CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
348	RTPrintf(List::tr("Processor supports %s: %s\n"), features[i].pszName, supported ? List::tr("yes") : List::tr("no"));
349	}
350	for (ULONG i = 0; i < processorCount; i++)
351	{
352	ULONG processorSpeed = 0;
353	CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
354	if (processorSpeed)
355	RTPrintf(List::tr("Processor#%u speed: %lu MHz\n"), i, processorSpeed);
356	else
357	RTPrintf(List::tr("Processor#%u speed: unknown\n"), i);
358	Bstr processorDescription;
359	CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
360	RTPrintf(List::tr("Processor#%u description: %ls\n"), i, processorDescription.raw());
361	}
362
363	ULONG memorySize = 0;
364	CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
365	RTPrintf(List::tr("Memory size: %lu MByte\n", "", memorySize), memorySize);
366
367	ULONG memoryAvailable = 0;
368	CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
369	RTPrintf(List::tr("Memory available: %lu MByte\n", "", memoryAvailable), memoryAvailable);
370
371	Bstr operatingSystem;
372	CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
373	RTPrintf(List::tr("Operating system: %ls\n"), operatingSystem.raw());
374
375	Bstr oSVersion;
376	CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
377	RTPrintf(List::tr("Operating system version: %ls\n"), oSVersion.raw());
378	return hrc;
379	}
380
381
382	/**
383	* List media information.
384	*
385	* @returns See produceList.
386	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
387	* @param aMedia Medium objects to list information for.
388	* @param pszParentUUIDStr String with the parent UUID string (or "base").
389	* @param fOptLong Long (@c true) or short list format.
390	*/
391	static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
392	const com::SafeIfaceArray<IMedium> &aMedia,
393	const char *pszParentUUIDStr,
394	bool fOptLong)
395	{
396	HRESULT hrc = S_OK;
397	for (size_t i = 0; i < aMedia.size(); ++i)
398	{
399	ComPtr<IMedium> pMedium = aMedia[i];
400
401	hrc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
402
403	RTPrintf("\n");
404
405	com::SafeIfaceArray<IMedium> children;
406	CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
407	if (children.size() > 0)
408	{
409	Bstr uuid;
410	pMedium->COMGETTER(Id)(uuid.asOutParam());
411
412	// depth first listing of child media
413	hrc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
414	}
415	}
416
417	return hrc;
418	}
419
420
421	/**
422	* List virtual image backends.
423	*
424	* @returns See produceList.
425	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
426	*/
427	static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox)
428	{
429	HRESULT hrc;
430	ComPtr<ISystemProperties> systemProperties;
431	CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
432	com::SafeIfaceArray<IMediumFormat> mediumFormats;
433	CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
434
435	RTPrintf(List::tr("Supported hard disk backends:\n\n"));
436	for (size_t i = 0; i < mediumFormats.size(); ++i)
437	{
438	/* General information */
439	Bstr id;
440	CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam()));
441
442	Bstr description;
443	CHECK_ERROR(mediumFormats[i],
444	COMGETTER(Name)(description.asOutParam()));
445
446	ULONG caps = 0;
447	com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
448	CHECK_ERROR(mediumFormats[i],
449	COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)));
450	for (ULONG j = 0; j < mediumFormatCap.size(); j++)
451	caps \|= mediumFormatCap[j];
452
453
454	RTPrintf(List::tr("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='"),
455	i, id.raw(), description.raw(), caps);
456
457	/* File extensions */
458	com::SafeArray<BSTR> fileExtensions;
459	com::SafeArray<DeviceType_T> deviceTypes;
460	CHECK_ERROR(mediumFormats[i],
461	DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
462	for (size_t j = 0; j < fileExtensions.size(); ++j)
463	{
464	RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
465	if (j != fileExtensions.size()-1)
466	RTPrintf(",");
467	}
468	RTPrintf("'");
469
470	/* Configuration keys */
471	com::SafeArray<BSTR> propertyNames;
472	com::SafeArray<BSTR> propertyDescriptions;
473	com::SafeArray<DataType_T> propertyTypes;
474	com::SafeArray<ULONG> propertyFlags;
475	com::SafeArray<BSTR> propertyDefaults;
476	CHECK_ERROR(mediumFormats[i],
477	DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
478	ComSafeArrayAsOutParam(propertyDescriptions),
479	ComSafeArrayAsOutParam(propertyTypes),
480	ComSafeArrayAsOutParam(propertyFlags),
481	ComSafeArrayAsOutParam(propertyDefaults)));
482
483	RTPrintf(List::tr(" properties=("));
484	if (propertyNames.size() > 0)
485	{
486	for (size_t j = 0; j < propertyNames.size(); ++j)
487	{
488	RTPrintf(List::tr("\n name='%ls' desc='%ls' type="),
489	Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
490	switch (propertyTypes[j])
491	{
492	case DataType_Int32: RTPrintf(List::tr("int")); break;
493	case DataType_Int8: RTPrintf(List::tr("byte")); break;
494	case DataType_String: RTPrintf(List::tr("string")); break;
495	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
496	case DataType_32BitHack: break; /* Shut up compiler warnings. */
497	#endif
498	}
499	RTPrintf(List::tr(" flags=%#04x"), propertyFlags[j]);
500	RTPrintf(List::tr(" default='%ls'"), Bstr(propertyDefaults[j]).raw());
501	if (j != propertyNames.size()-1)
502	RTPrintf(", ");
503	}
504	}
505	RTPrintf(")\n");
506	}
507	return hrc;
508	}
509
510
511	/**
512	* List USB devices attached to the host.
513	*
514	* @returns See produceList.
515	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
516	*/
517	static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox)
518	{
519	HRESULT hrc;
520	ComPtr<IHost> Host;
521	CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
522
523	SafeIfaceArray<IHostUSBDevice> CollPtr;
524	CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
525
526	RTPrintf(List::tr("Host USB Devices:\n\n"));
527
528	if (CollPtr.size() == 0)
529	{
530	RTPrintf(List::tr("<none>\n\n"));
531	}
532	else
533	{
534	for (size_t i = 0; i < CollPtr.size(); ++i)
535	{
536	ComPtr<IHostUSBDevice> dev = CollPtr[i];
537
538	/* Query info. */
539	Bstr id;
540	CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1);
541	USHORT usVendorId;
542	CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1);
543	USHORT usProductId;
544	CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1);
545	USHORT bcdRevision;
546	CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1);
547	USHORT usPort;
548	CHECK_ERROR_RET(dev, COMGETTER(Port)(&usPort), 1);
549	USHORT usVersion;
550	CHECK_ERROR_RET(dev, COMGETTER(Version)(&usVersion), 1);
551	USBConnectionSpeed_T enmSpeed;
552	CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
553
554	RTPrintf(List::tr(
555	"UUID: %s\n"
556	"VendorId: %#06x (%04X)\n"
557	"ProductId: %#06x (%04X)\n"
558	"Revision: %u.%u (%02u%02u)\n"
559	"Port: %u\n"),
560	Utf8Str(id).c_str(),
561	usVendorId, usVendorId, usProductId, usProductId,
562	bcdRevision >> 8, bcdRevision & 0xff,
563	bcdRevision >> 8, bcdRevision & 0xff,
564	usPort);
565
566	const char *pszSpeed = "?";
567	switch (enmSpeed)
568	{
569	case USBConnectionSpeed_Low:
570	pszSpeed = List::tr("Low");
571	break;
572	case USBConnectionSpeed_Full:
573	pszSpeed = List::tr("Full");
574	break;
575	case USBConnectionSpeed_High:
576	pszSpeed = List::tr("High");
577	break;
578	case USBConnectionSpeed_Super:
579	pszSpeed = List::tr("Super");
580	break;
581	case USBConnectionSpeed_SuperPlus:
582	pszSpeed = List::tr("SuperPlus");
583	break;
584	default:
585	ASSERT(false);
586	break;
587	}
588
589	RTPrintf(List::tr("USB version/speed: %u/%s\n"), usVersion, pszSpeed);
590
591	/* optional stuff. */
592	SafeArray<BSTR> CollDevInfo;
593	Bstr bstr;
594	CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1);
595	if (CollDevInfo.size() >= 1)
596	bstr = Bstr(CollDevInfo[0]);
597	if (!bstr.isEmpty())
598	RTPrintf(List::tr("Manufacturer: %ls\n"), bstr.raw());
599	if (CollDevInfo.size() >= 2)
600	bstr = Bstr(CollDevInfo[1]);
601	if (!bstr.isEmpty())
602	RTPrintf(List::tr("Product: %ls\n"), bstr.raw());
603	CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
604	if (!bstr.isEmpty())
605	RTPrintf(List::tr("SerialNumber: %ls\n"), bstr.raw());
606	CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
607	if (!bstr.isEmpty())
608	RTPrintf(List::tr("Address: %ls\n"), bstr.raw());
609	CHECK_ERROR_RET(dev, COMGETTER(PortPath)(bstr.asOutParam()), 1);
610	if (!bstr.isEmpty())
611	RTPrintf(List::tr("Port path: %ls\n"), bstr.raw());
612
613	/* current state */
614	USBDeviceState_T state;
615	CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1);
616	const char *pszState = "?";
617	switch (state)
618	{
619	case USBDeviceState_NotSupported:
620	pszState = List::tr("Not supported");
621	break;
622	case USBDeviceState_Unavailable:
623	pszState = List::tr("Unavailable");
624	break;
625	case USBDeviceState_Busy:
626	pszState = List::tr("Busy");
627	break;
628	case USBDeviceState_Available:
629	pszState = List::tr("Available");
630	break;
631	case USBDeviceState_Held:
632	pszState = List::tr("Held");
633	break;
634	case USBDeviceState_Captured:
635	pszState = List::tr("Captured");
636	break;
637	default:
638	ASSERT(false);
639	break;
640	}
641	RTPrintf(List::tr("Current State: %s\n\n"), pszState);
642	}
643	}
644	return hrc;
645	}
646
647
648	/**
649	* List USB filters.
650	*
651	* @returns See produceList.
652	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
653	*/
654	static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox)
655	{
656	HRESULT hrc;
657
658	RTPrintf(List::tr("Global USB Device Filters:\n\n"));
659
660	ComPtr<IHost> host;
661	CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(host.asOutParam()), 1);
662
663	SafeIfaceArray<IHostUSBDeviceFilter> coll;
664	CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1);
665
666	if (coll.size() == 0)
667	{
668	RTPrintf(List::tr("<none>\n\n"));
669	}
670	else
671	{
672	for (size_t index = 0; index < coll.size(); ++index)
673	{
674	ComPtr<IHostUSBDeviceFilter> flt = coll[index];
675
676	/* Query info. */
677
678	RTPrintf(List::tr("Index: %zu\n"), index);
679
680	BOOL active = FALSE;
681	CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
682	RTPrintf(List::tr("Active: %s\n"), active ? List::tr("yes") : List::tr("no"));
683
684	USBDeviceFilterAction_T action;
685	CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
686	const char *pszAction = List::tr("<invalid>");
687	switch (action)
688	{
689	case USBDeviceFilterAction_Ignore:
690	pszAction = List::tr("Ignore");
691	break;
692	case USBDeviceFilterAction_Hold:
693	pszAction = List::tr("Hold");
694	break;
695	default:
696	break;
697	}
698	RTPrintf(List::tr("Action: %s\n"), pszAction);
699
700	Bstr bstr;
701	CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
702	RTPrintf(List::tr("Name: %ls\n"), bstr.raw());
703	CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
704	RTPrintf(List::tr("VendorId: %ls\n"), bstr.raw());
705	CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
706	RTPrintf(List::tr("ProductId: %ls\n"), bstr.raw());
707	CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
708	RTPrintf(List::tr("Revision: %ls\n"), bstr.raw());
709	CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
710	RTPrintf(List::tr("Manufacturer: %ls\n"), bstr.raw());
711	CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
712	RTPrintf(List::tr("Product: %ls\n"), bstr.raw());
713	CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
714	RTPrintf(List::tr("Serial Number: %ls\n"), bstr.raw());
715	CHECK_ERROR_RET(flt, COMGETTER(Port)(bstr.asOutParam()), 1);
716	RTPrintf(List::tr("Port: %ls\n\n"), bstr.raw());
717	}
718	}
719	return hrc;
720	}
721
722	/**
723	* Returns the chipset type as a string.
724	*
725	* @return Chipset type as a string.
726	* @param enmType Chipset type to convert.
727	*/
728	static const char *chipsetTypeToStr(ChipsetType_T enmType)
729	{
730	switch (enmType)
731	{
732	case ChipsetType_PIIX3: return "PIIX3";
733	case ChipsetType_ICH9: return "ICH9";
734	case ChipsetType_ARMv8Virtual: return "ARMv8Virtual";
735	case ChipsetType_Null:
736	default:
737	break;
738	}
739
740	return "<Unknown>";
741	}
742
743	/**
744	* Returns a platform architecture as a string.
745	*
746	* @return Platform architecture as a string.
747	* @param enmArch Platform architecture to convert.
748	*/
749	static const char *platformArchitectureToStr(PlatformArchitecture_T enmArch)
750	{
751	switch (enmArch)
752	{
753	case PlatformArchitecture_x86: return "x86";
754	case PlatformArchitecture_ARM: return "ARMv8";
755	default:
756	break;
757	}
758
759	return "<Unknown>";
760	}
761
762	/** @todo r=andy Make use of SHOW_ULONG_PROP and friends like in VBoxManageInfo to have a more uniform / prettier output.
763	* Use nesting (as padding / tabs). */
764
765	/**
766	* List chipset properties.
767	*
768	* @returns See produceList.
769	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
770	*/
771	static HRESULT listPlatformChipsetProperties(const ComPtr<IPlatformProperties> &pPlatformProperties, ChipsetType_T enmChipsetType)
772	{
773	const char *pszChipset = chipsetTypeToStr(enmChipsetType);
774	AssertPtrReturn(pszChipset, E_INVALIDARG);
775
776	/* Note: Keep the chipset name within the description -- makes it easier to grep for specific chipsts manually. */
777	ULONG ulValue;
778	pPlatformProperties->GetMaxNetworkAdapters(enmChipsetType, &ulValue);
779	RTPrintf(List::tr("Maximum %s Network Adapter count: %u\n"), pszChipset, ulValue);
780	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_IDE, &ulValue);
781	RTPrintf(List::tr("Maximum %s IDE Controllers: %u\n"), pszChipset, ulValue);
782	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SATA, &ulValue);
783	RTPrintf(List::tr("Maximum %s SATA Controllers: %u\n"), pszChipset, ulValue);
784	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SCSI, &ulValue);
785	RTPrintf(List::tr("Maximum %s SCSI Controllers: %u\n"), pszChipset, ulValue);
786	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SAS, &ulValue);
787	RTPrintf(List::tr("Maximum %s SAS Controllers: %u\n"), pszChipset, ulValue);
788	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_PCIe, &ulValue);
789	RTPrintf(List::tr("Maximum %s NVMe Controllers: %u\n"), pszChipset, ulValue);
790	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_VirtioSCSI, &ulValue);
791	RTPrintf(List::tr("Maximum %s virtio-scsi Controllers: %u\n"), pszChipset, ulValue);
792	pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_Floppy, &ulValue);
793	RTPrintf(List::tr("Maximum %s Floppy Controllers:%u\n"), pszChipset, ulValue);
794
795	return S_OK;
796	}
797
798	static HRESULT listPlatformProperties(const ComPtr<IPlatformProperties> &platformProperties)
799	{
800	ULONG ulValue;
801	platformProperties->COMGETTER(SerialPortCount)(&ulValue);
802	RTPrintf(List::tr("Maximum Serial Port count: %u\n"), ulValue);
803	platformProperties->COMGETTER(ParallelPortCount)(&ulValue);
804	RTPrintf(List::tr("Maximum Parallel Port count: %u\n"), ulValue);
805	platformProperties->COMGETTER(MaxBootPosition)(&ulValue);
806	RTPrintf(List::tr("Maximum Boot Position: %u\n"), ulValue);
807	platformProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
808	RTPrintf(List::tr("Maximum Floppy Port count: %u\n"), ulValue);
809	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
810	RTPrintf(List::tr("Maximum Floppy Devices per Port: %u\n"), ulValue);
811	platformProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
812	RTPrintf(List::tr("Maximum virtio-scsi Port count: %u\n"), ulValue);
813	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
814	RTPrintf(List::tr("Maximum virtio-scsi Devices per Port: %u\n"), ulValue);
815	platformProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
816	RTPrintf(List::tr("Maximum IDE Port count: %u\n"), ulValue);
817	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
818	RTPrintf(List::tr("Maximum IDE Devices per port: %u\n"), ulValue);
819	platformProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
820	RTPrintf(List::tr("Maximum SATA Port count: %u\n"), ulValue);
821	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
822	RTPrintf(List::tr("Maximum SATA Device per port: %u\n"), ulValue);
823	platformProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
824	RTPrintf(List::tr("Maximum SCSI Port count: %u\n"), ulValue);
825	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
826	RTPrintf(List::tr("Maximum SCSI Devices per port: %u\n"), ulValue);
827	platformProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
828	RTPrintf(List::tr("Maximum SAS Port count: %u\n"), ulValue);
829	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
830	RTPrintf(List::tr("Maximum SAS Devices per Port: %u\n"), ulValue);
831	platformProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
832	RTPrintf(List::tr("Maximum NVMe Port count: %u\n"), ulValue);
833	platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
834	RTPrintf(List::tr("Maximum NVMe Devices per Port: %u\n"), ulValue);
835
836	SafeArray <ChipsetType_T> saChipset;
837	platformProperties->COMGETTER(SupportedChipsetTypes(ComSafeArrayAsOutParam(saChipset)));
838
839	RTPrintf(List::tr("Supported chipsets: "));
840	for (size_t i = 0; i < saChipset.size(); i++)
841	{
842	if (i > 0)
843	RTPrintf(", ");
844	RTPrintf("%s", chipsetTypeToStr(saChipset[i]));
845	}
846	RTPrintf("\n");
847
848	for (size_t i = 0; i < saChipset.size(); i++)
849	{
850	if (i > 0)
851	RTPrintf("\n");
852	RTPrintf(List::tr("%s chipset properties:\n"), chipsetTypeToStr(saChipset[i]));
853	listPlatformChipsetProperties(platformProperties, saChipset[i]);
854	}
855
856	return S_OK;
857	}
858
859	/**
860	* List system properties.
861	*
862	* @returns See produceList.
863	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
864	*/
865	static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox)
866	{
867	ComPtr<ISystemProperties> systemProperties;
868	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
869
870	ComPtr<IPlatformProperties> hostPlatformProperties;
871	CHECK_ERROR2I_RET(systemProperties, COMGETTER(Platform)(hostPlatformProperties.asOutParam()), hrcCheck);
872
873	Bstr str;
874	ULONG ulValue;
875	LONG64 i64Value;
876	BOOL fValue;
877	const char *psz;
878
879	pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
880	RTPrintf(List::tr("API version: %ls\n"), str.raw());
881
882	systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
883	RTPrintf(List::tr("Minimum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
884	systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
885	RTPrintf(List::tr("Maximum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
886	systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
887	RTPrintf(List::tr("Minimum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
888	systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
889	RTPrintf(List::tr("Maximum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
890	systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
891	RTPrintf(List::tr("Maximum guest monitor count: %u\n"), ulValue);
892	systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
893	RTPrintf(List::tr("Minimum guest CPU count: %u\n"), ulValue);
894	systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
895	RTPrintf(List::tr("Maximum guest CPU count: %u\n"), ulValue);
896	systemProperties->COMGETTER(InfoVDSize)(&i64Value);
897	RTPrintf(List::tr("Virtual disk limit (info): %lld Bytes\n", "" , i64Value), i64Value);
898
899	#if 0
900	systemProperties->GetFreeDiskSpaceWarning(&i64Value);
901	RTPrintf(List::tr("Free disk space warning at: %u Bytes\n", "", i64Value), i64Value);
902	systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
903	RTPrintf(List::tr("Free disk space warning at: %u %%\n"), ulValue);
904	systemProperties->GetFreeDiskSpaceError(&i64Value);
905	RTPrintf(List::tr("Free disk space error at: %u Bytes\n", "", i64Value), i64Value);
906	systemProperties->GetFreeDiskSpacePercentError(&ulValue);
907	RTPrintf(List::tr("Free disk space error at: %u %%\n"), ulValue);
908	#endif
909	systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
910	RTPrintf(List::tr("Default machine folder: %ls\n"), str.raw());
911	hostPlatformProperties->COMGETTER(RawModeSupported)(&fValue);
912	RTPrintf(List::tr("Raw-mode Supported: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
913	hostPlatformProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
914	RTPrintf(List::tr("Exclusive HW virtualization use: %s\n"), fValue ? List::tr("on") : List::tr("off"));
915	systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
916	RTPrintf(List::tr("Default hard disk format: %ls\n"), str.raw());
917	systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
918	RTPrintf(List::tr("VRDE auth library: %ls\n"), str.raw());
919	systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
920	RTPrintf(List::tr("Webservice auth. library: %ls\n"), str.raw());
921	systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
922	RTPrintf(List::tr("Remote desktop ExtPack: %ls\n"), str.raw());
923	systemProperties->COMGETTER(DefaultCryptoExtPack)(str.asOutParam());
924	RTPrintf(List::tr("VM encryption ExtPack: %ls\n"), str.raw());
925	systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
926	RTPrintf(List::tr("Log history count: %u\n"), ulValue);
927	systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
928	RTPrintf(List::tr("Default frontend: %ls\n"), str.raw());
929	AudioDriverType_T enmAudio;
930	systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
931	switch (enmAudio)
932	{
933	case AudioDriverType_Default: psz = List::tr("Default"); break;
934	case AudioDriverType_Null: psz = List::tr("Null"); break;
935	case AudioDriverType_OSS: psz = "OSS"; break;
936	case AudioDriverType_ALSA: psz = "ALSA"; break;
937	case AudioDriverType_Pulse: psz = "PulseAudio"; break;
938	case AudioDriverType_WinMM: psz = "WinMM"; break;
939	case AudioDriverType_DirectSound: psz = "DirectSound"; break;
940	case AudioDriverType_WAS: psz = "Windows Audio Session"; break;
941	case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
942	case AudioDriverType_SolAudio: psz = "SolAudio"; break;
943	case AudioDriverType_MMPM: psz = "MMPM"; break;
944	default: psz = List::tr("Unknown");
945	}
946	RTPrintf(List::tr("Default audio driver: %s\n"), psz);
947	systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
948	RTPrintf(List::tr("Autostart database path: %ls\n"), str.raw());
949	systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
950	RTPrintf(List::tr("Default Guest Additions ISO: %ls\n"), str.raw());
951	systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
952	RTPrintf(List::tr("Logging Level: %ls\n"), str.raw());
953	ProxyMode_T enmProxyMode = (ProxyMode_T)42;
954	systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
955	psz = List::tr("Unknown");
956	switch (enmProxyMode)
957	{
958	case ProxyMode_System: psz = List::tr("System"); break;
959	case ProxyMode_NoProxy: psz = List::tr("NoProxy"); break;
960	case ProxyMode_Manual: psz = List::tr("Manual"); break;
961	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
962	case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */
963	#endif
964	}
965	RTPrintf(List::tr("Proxy Mode: %s\n"), psz);
966	systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
967	RTPrintf(List::tr("Proxy URL: %ls\n"), str.raw());
968	#ifdef VBOX_WITH_MAIN_NLS
969	systemProperties->COMGETTER(LanguageId)(str.asOutParam());
970	RTPrintf(List::tr("User language: %ls\n"), str.raw());
971	#endif
972
973	RTPrintf("Host platform properties:\n");
974	listPlatformProperties(hostPlatformProperties);
975
976	/* Separate host system / platform properties stuff from guest platform properties a bit. */
977	RTPrintf("\n");
978
979	SafeArray <PlatformArchitecture_T> saPlatformArch;
980	systemProperties->COMGETTER(SupportedPlatformArchitectures(ComSafeArrayAsOutParam(saPlatformArch)));
981	RTPrintf("Supported platform architectures: ");
982	for (size_t i = 0; i < saPlatformArch.size(); ++i)
983	{
984	if (i > 0)
985	RTPrintf(",");
986	RTPrintf(platformArchitectureToStr(saPlatformArch[i]));
987	}
988	RTPrintf("\n\n");
989
990	for (size_t i = 0; i < saPlatformArch.size(); ++i)
991	{
992	if (i > 0)
993	RTPrintf("\n");
994	ComPtr<IPlatformProperties> platformProperties;
995	pVirtualBox->GetPlatformProperties(saPlatformArch[i], platformProperties.asOutParam());
996	RTPrintf(List::tr("%s platform properties:\n"), platformArchitectureToStr(saPlatformArch[i]));
997	listPlatformProperties(platformProperties);
998	}
999
1000	return S_OK;
1001	}
1002
1003	#ifdef VBOX_WITH_UPDATE_AGENT
1004	static HRESULT listUpdateAgentConfig(ComPtr<IUpdateAgent> ptrUpdateAgent)
1005	{
1006	BOOL fValue;
1007	ptrUpdateAgent->COMGETTER(Enabled)(&fValue);
1008	RTPrintf(List::tr("Enabled: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
1009	ULONG ulValue;
1010	ptrUpdateAgent->COMGETTER(CheckCount)(&ulValue);
1011	RTPrintf(List::tr("Check count: %u\n"), ulValue);
1012	ptrUpdateAgent->COMGETTER(CheckFrequency)(&ulValue);
1013	if (ulValue == 0)
1014	RTPrintf(List::tr("Check frequency: never\n"));
1015	else if (ulValue == 1)
1016	RTPrintf(List::tr("Check frequency: every day\n"));
1017	else
1018	RTPrintf(List::tr("Check frequency: every %u days\n", "", ulValue), ulValue);
1019
1020	Bstr str;
1021	const char *psz;
1022	UpdateChannel_T enmUpdateChannel;
1023	ptrUpdateAgent->COMGETTER(Channel)(&enmUpdateChannel);
1024	switch (enmUpdateChannel)
1025	{
1026	case UpdateChannel_Stable:
1027	psz = List::tr("Stable: Maintenance and minor releases within the same major release");
1028	break;
1029	case UpdateChannel_All:
1030	psz = List::tr("All releases: All stable releases, including major versions");
1031	break;
1032	case UpdateChannel_WithBetas:
1033	psz = List::tr("With Betas: All stable and major releases, including beta versions");
1034	break;
1035	case UpdateChannel_WithTesting:
1036	psz = List::tr("With Testing: All stable, major and beta releases, including testing versions");
1037	break;
1038	default:
1039	psz = List::tr("Unset");
1040	break;
1041	}
1042	RTPrintf(List::tr("Channel: %s\n"), psz);
1043	ptrUpdateAgent->COMGETTER(RepositoryURL)(str.asOutParam());
1044	RTPrintf(List::tr("Repository: %ls\n"), str.raw());
1045	ptrUpdateAgent->COMGETTER(LastCheckDate)(str.asOutParam());
1046	RTPrintf(List::tr("Last check date: %ls\n"), str.raw());
1047
1048	return S_OK;
1049	}
1050
1051	static HRESULT listUpdateAgents(const ComPtr<IVirtualBox> &pVirtualBox)
1052	{
1053	ComPtr<IHost> pHost;
1054	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), RTEXITCODE_FAILURE);
1055
1056	ComPtr<IUpdateAgent> pUpdateHost;
1057	CHECK_ERROR2I_RET(pHost, COMGETTER(UpdateHost)(pUpdateHost.asOutParam()), RTEXITCODE_FAILURE);
1058	/** @todo Add other update agents here. */
1059
1060	return listUpdateAgentConfig(pUpdateHost);
1061	}
1062	#endif /* VBOX_WITH_UPDATE_AGENT */
1063
1064	/**
1065	* Helper for listDhcpServers() that shows a DHCP configuration.
1066	*/
1067	static HRESULT showDhcpConfig(ComPtr<IDHCPConfig> ptrConfig)
1068	{
1069	HRESULT hrcRet = S_OK;
1070
1071	ULONG secs = 0;
1072	CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MinLeaseTime)(&secs), hrcRet = hrcCheck);
1073	if (secs == 0)
1074	RTPrintf(List::tr(" minLeaseTime: default\n"));
1075	else
1076	RTPrintf(List::tr(" minLeaseTime: %u sec\n"), secs);
1077
1078	secs = 0;
1079	CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(DefaultLeaseTime)(&secs), hrcRet = hrcCheck);
1080	if (secs == 0)
1081	RTPrintf(List::tr(" defaultLeaseTime: default\n"));
1082	else
1083	RTPrintf(List::tr(" defaultLeaseTime: %u sec\n"), secs);
1084
1085	secs = 0;
1086	CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MaxLeaseTime)(&secs), hrcRet = hrcCheck);
1087	if (secs == 0)
1088	RTPrintf(List::tr(" maxLeaseTime: default\n"));
1089	else
1090	RTPrintf(List::tr(" maxLeaseTime: %u sec\n"), secs);
1091
1092	com::SafeArray<DHCPOption_T> Options;
1093	HRESULT hrc;
1094	CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(ForcedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1095	if (FAILED(hrc))
1096	RTPrintf(List::tr(" Forced options: %Rhrc\n"), hrc);
1097	else if (Options.size() == 0)
1098	RTPrintf(List::tr(" Forced options: None\n"));
1099	else
1100	{
1101	RTPrintf(List::tr(" Forced options: "));
1102	for (size_t i = 0; i < Options.size(); i++)
1103	RTPrintf(i ? ", %u" : "%u", Options[i]);
1104	RTPrintf("\n");
1105	}
1106
1107	CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(SuppressedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1108	if (FAILED(hrc))
1109	RTPrintf(List::tr(" Suppressed opt.s: %Rhrc\n"), hrc);
1110	else if (Options.size() == 0)
1111	RTPrintf(List::tr(" Suppressed opts.: None\n"));
1112	else
1113	{
1114	RTPrintf(List::tr(" Suppressed opts.: "));
1115	for (size_t i = 0; i < Options.size(); i++)
1116	RTPrintf(i ? ", %u" : "%u", Options[i]);
1117	RTPrintf("\n");
1118	}
1119
1120	com::SafeArray<DHCPOptionEncoding_T> Encodings;
1121	com::SafeArray<BSTR> Values;
1122	CHECK_ERROR2_STMT(hrc, ptrConfig, GetAllOptions(ComSafeArrayAsOutParam(Options),
1123	ComSafeArrayAsOutParam(Encodings),
1124	ComSafeArrayAsOutParam(Values)), hrcRet = hrc);
1125	if (FAILED(hrc))
1126	RTPrintf(List::tr(" DHCP options: %Rhrc\n"), hrc);
1127	else if (Options.size() != Encodings.size() \|\| Options.size() != Values.size())
1128	{
1129	RTPrintf(List::tr(" DHCP options: Return count mismatch: %zu, %zu, %zu\n"),
1130	Options.size(), Encodings.size(), Values.size());
1131	hrcRet = E_FAIL;
1132	}
1133	else if (Options.size() == 0)
1134	RTPrintf(List::tr(" DHCP options: None\n"));
1135	else
1136	for (size_t i = 0; i < Options.size(); i++)
1137	{
1138	switch (Encodings[i])
1139	{
1140	case DHCPOptionEncoding_Normal:
1141	RTPrintf(List::tr(" %3d/legacy: %ls\n"), Options[i], Values[i]);
1142	break;
1143	case DHCPOptionEncoding_Hex:
1144	RTPrintf(" %3d/hex: %ls\n", Options[i], Values[i]);
1145	break;
1146	default:
1147	RTPrintf(" %3d/%u?: %ls\n", Options[i], Encodings[i], Values[i]);
1148	break;
1149	}
1150	}
1151
1152	return S_OK;
1153	}
1154
1155
1156	/**
1157	* List DHCP servers.
1158	*
1159	* @returns See produceList.
1160	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
1161	*/
1162	static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox)
1163	{
1164	HRESULT hrcRet = S_OK;
1165	com::SafeIfaceArray<IDHCPServer> DHCPServers;
1166	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(DHCPServers)), hrcCheck);
1167	for (size_t i = 0; i < DHCPServers.size(); ++i)
1168	{
1169	if (i > 0)
1170	RTPrintf("\n");
1171
1172	ComPtr<IDHCPServer> ptrDHCPServer = DHCPServers[i];
1173	Bstr bstr;
1174	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkName)(bstr.asOutParam()), hrcRet = hrcCheck);
1175	RTPrintf(List::tr("NetworkName: %ls\n"), bstr.raw());
1176
1177	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(IPAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1178	RTPrintf("Dhcpd IP: %ls\n", bstr.raw());
1179
1180	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(LowerIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1181	RTPrintf(List::tr("LowerIPAddress: %ls\n"), bstr.raw());
1182
1183	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(UpperIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1184	RTPrintf(List::tr("UpperIPAddress: %ls\n"), bstr.raw());
1185
1186	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkMask)(bstr.asOutParam()), hrcRet = hrcCheck);
1187	RTPrintf(List::tr("NetworkMask: %ls\n"), bstr.raw());
1188
1189	BOOL fEnabled = FALSE;
1190	CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(Enabled)(&fEnabled), hrcRet = hrcCheck);
1191	RTPrintf(List::tr("Enabled: %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
1192
1193	/* Global configuration: */
1194	RTPrintf(List::tr("Global Configuration:\n"));
1195	HRESULT hrc;
1196	ComPtr<IDHCPGlobalConfig> ptrGlobal;
1197	CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GlobalConfig)(ptrGlobal.asOutParam()), hrcRet = hrc);
1198	if (SUCCEEDED(hrc))
1199	{
1200	hrc = showDhcpConfig(ptrGlobal);
1201	if (FAILED(hrc))
1202	hrcRet = hrc;
1203	}
1204
1205	/* Group configurations: */
1206	com::SafeIfaceArray<IDHCPGroupConfig> Groups;
1207	CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GroupConfigs)(ComSafeArrayAsOutParam(Groups)), hrcRet = hrc);
1208	if (FAILED(hrc))
1209	RTPrintf(List::tr("Groups: %Rrc\n"), hrc);
1210	else if (Groups.size() == 0)
1211	RTPrintf(List::tr("Groups: None\n"));
1212	else
1213	{
1214	for (size_t iGrp = 0; iGrp < Groups.size(); iGrp++)
1215	{
1216	CHECK_ERROR2I_STMT(Groups[iGrp], COMGETTER(Name)(bstr.asOutParam()), hrcRet = hrcCheck);
1217	RTPrintf(List::tr("Group: %ls\n"), bstr.raw());
1218
1219	com::SafeIfaceArray<IDHCPGroupCondition> Conditions;
1220	CHECK_ERROR2_STMT(hrc, Groups[iGrp], COMGETTER(Conditions)(ComSafeArrayAsOutParam(Conditions)), hrcRet = hrc);
1221	if (FAILED(hrc))
1222	RTPrintf(List::tr(" Conditions: %Rhrc\n"), hrc);
1223	else if (Conditions.size() == 0)
1224	RTPrintf(List::tr(" Conditions: None\n"));
1225	else
1226	for (size_t iCond = 0; iCond < Conditions.size(); iCond++)
1227	{
1228	BOOL fInclusive = TRUE;
1229	CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Inclusive)(&fInclusive), hrcRet = hrc);
1230	DHCPGroupConditionType_T enmType = DHCPGroupConditionType_MAC;
1231	CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Type)(&enmType), hrcRet = hrc);
1232	CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Value)(bstr.asOutParam()), hrcRet = hrc);
1233
1234	RTPrintf(List::tr(" Conditions: %s %s %ls\n"),
1235	fInclusive ? List::tr("include") : List::tr("exclude"),
1236	enmType == DHCPGroupConditionType_MAC ? "MAC "
1237	: enmType == DHCPGroupConditionType_MACWildcard ? "MAC* "
1238	: enmType == DHCPGroupConditionType_vendorClassID ? "VendorCID "
1239	: enmType == DHCPGroupConditionType_vendorClassIDWildcard ? "VendorCID*"
1240	: enmType == DHCPGroupConditionType_userClassID ? "UserCID "
1241	: enmType == DHCPGroupConditionType_userClassIDWildcard ? "UserCID* "
1242	: "!UNKNOWN! ",
1243	bstr.raw());
1244	}
1245
1246	hrc = showDhcpConfig(Groups[iGrp]);
1247	if (FAILED(hrc))
1248	hrcRet = hrc;
1249	}
1250	Groups.setNull();
1251	}
1252
1253	/* Individual host / NIC configurations: */
1254	com::SafeIfaceArray<IDHCPIndividualConfig> Hosts;
1255	CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(IndividualConfigs)(ComSafeArrayAsOutParam(Hosts)), hrcRet = hrc);
1256	if (FAILED(hrc))
1257	RTPrintf(List::tr("Individual Configs: %Rrc\n"), hrc);
1258	else if (Hosts.size() == 0)
1259	RTPrintf(List::tr("Individual Configs: None\n"));
1260	else
1261	{
1262	for (size_t iHost = 0; iHost < Hosts.size(); iHost++)
1263	{
1264	DHCPConfigScope_T enmScope = DHCPConfigScope_MAC;
1265	CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Scope)(&enmScope), hrcRet = hrcCheck);
1266
1267	if (enmScope == DHCPConfigScope_MAC)
1268	{
1269	CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MACAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1270	RTPrintf(List::tr("Individual Config: MAC %ls\n"), bstr.raw());
1271	}
1272	else
1273	{
1274	ULONG uSlot = 0;
1275	CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Slot)(&uSlot), hrcRet = hrcCheck);
1276	CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MachineId)(bstr.asOutParam()), hrcRet = hrcCheck);
1277	Bstr bstrMACAddress;
1278	hrc = Hosts[iHost]->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); /* No CHECK_ERROR2 stuff! */
1279	if (SUCCEEDED(hrc))
1280	RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %ls\n"), bstr.raw(), uSlot,
1281	bstrMACAddress.raw());
1282	else
1283	RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %Rhrc\n"), bstr.raw(), uSlot, hrc);
1284	}
1285
1286	CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(FixedAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1287	if (bstr.isNotEmpty())
1288	RTPrintf(List::tr(" Fixed Address: %ls\n"), bstr.raw());
1289	else
1290	RTPrintf(List::tr(" Fixed Address: dynamic\n"));
1291
1292	hrc = showDhcpConfig(Hosts[iHost]);
1293	if (FAILED(hrc))
1294	hrcRet = hrc;
1295	}
1296	Hosts.setNull();
1297	}
1298	}
1299
1300	return hrcRet;
1301	}
1302
1303	/**
1304	* List extension packs.
1305	*
1306	* @returns See produceList.
1307	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
1308	*/
1309	static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
1310	{
1311	ComObjPtr<IExtPackManager> ptrExtPackMgr;
1312	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
1313
1314	SafeIfaceArray<IExtPack> extPacks;
1315	CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
1316	RTPrintf(List::tr("Extension Packs: %u\n"), extPacks.size());
1317
1318	HRESULT hrc = S_OK;
1319	for (size_t i = 0; i < extPacks.size(); i++)
1320	{
1321	/* Read all the properties. */
1322	Bstr bstrName;
1323	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
1324	Bstr bstrDesc;
1325	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
1326	Bstr bstrVersion;
1327	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
1328	ULONG uRevision;
1329	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
1330	Bstr bstrEdition;
1331	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
1332	Bstr bstrVrdeModule;
1333	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
1334	Bstr bstrCryptoModule;
1335	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(CryptoModule)(bstrCryptoModule.asOutParam()),hrc=hrcCheck; bstrCryptoModule.setNull());
1336	BOOL fUsable;
1337	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
1338	Bstr bstrWhy;
1339	CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
1340
1341	/* Display them. */
1342	if (i)
1343	RTPrintf("\n");
1344	RTPrintf(List::tr(
1345	"Pack no.%2zu: %ls\n"
1346	"Version: %ls\n"
1347	"Revision: %u\n"
1348	"Edition: %ls\n"
1349	"Description: %ls\n"
1350	"VRDE Module: %ls\n"
1351	"Crypto Module: %ls\n"
1352	"Usable: %RTbool\n"
1353	"Why unusable: %ls\n"),
1354	i, bstrName.raw(),
1355	bstrVersion.raw(),
1356	uRevision,
1357	bstrEdition.raw(),
1358	bstrDesc.raw(),
1359	bstrVrdeModule.raw(),
1360	bstrCryptoModule.raw(),
1361	fUsable != FALSE,
1362	bstrWhy.raw());
1363
1364	/* Query plugins and display them. */
1365	}
1366	return hrc;
1367	}
1368
1369
1370	/**
1371	* List machine groups.
1372	*
1373	* @returns See produceList.
1374	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
1375	*/
1376	static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
1377	{
1378	SafeArray<BSTR> groups;
1379	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
1380
1381	for (size_t i = 0; i < groups.size(); i++)
1382	{
1383	RTPrintf("\"%ls\"\n", groups[i]);
1384	}
1385	return S_OK;
1386	}
1387
1388
1389	/**
1390	* List video capture devices.
1391	*
1392	* @returns See produceList.
1393	* @param pVirtualBox Reference to the IVirtualBox pointer.
1394	*/
1395	static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> &pVirtualBox)
1396	{
1397	HRESULT hrc;
1398	ComPtr<IHost> host;
1399	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1400	com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
1401	CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
1402	RTPrintf(List::tr("Video Input Devices: %u\n"), hostVideoInputDevices.size());
1403	for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
1404	{
1405	ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
1406	Bstr name;
1407	p->COMGETTER(Name)(name.asOutParam());
1408	Bstr path;
1409	p->COMGETTER(Path)(path.asOutParam());
1410	Bstr alias;
1411	p->COMGETTER(Alias)(alias.asOutParam());
1412	RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
1413	}
1414	return hrc;
1415	}
1416
1417	/**
1418	* List supported screen shot formats.
1419	*
1420	* @returns See produceList.
1421	* @param pVirtualBox Reference to the IVirtualBox pointer.
1422	*/
1423	static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> &pVirtualBox)
1424	{
1425	HRESULT hrc = S_OK;
1426	ComPtr<ISystemProperties> systemProperties;
1427	CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
1428	com::SafeArray<BitmapFormat_T> formats;
1429	CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
1430
1431	RTPrintf(List::tr("Supported %d screen shot formats:\n", "", formats.size()), formats.size());
1432	for (size_t i = 0; i < formats.size(); ++i)
1433	{
1434	uint32_t u32Format = (uint32_t)formats[i];
1435	char szFormat[5];
1436	szFormat[0] = RT_BYTE1(u32Format);
1437	szFormat[1] = RT_BYTE2(u32Format);
1438	szFormat[2] = RT_BYTE3(u32Format);
1439	szFormat[3] = RT_BYTE4(u32Format);
1440	szFormat[4] = 0;
1441	RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
1442	}
1443	return hrc;
1444	}
1445
1446	/**
1447	* List available cloud providers.
1448	*
1449	* @returns See produceList.
1450	* @param pVirtualBox Reference to the IVirtualBox pointer.
1451	*/
1452	static HRESULT listCloudProviders(const ComPtr<IVirtualBox> &pVirtualBox)
1453	{
1454	HRESULT hrc = S_OK;
1455	ComPtr<ICloudProviderManager> pCloudProviderManager;
1456	CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1457	com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1458	CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1459
1460	RTPrintf(List::tr("Supported %d cloud providers:\n", "", apCloudProviders.size()), apCloudProviders.size());
1461	for (size_t i = 0; i < apCloudProviders.size(); ++i)
1462	{
1463	ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1464	Bstr bstrProviderName;
1465	pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
1466	RTPrintf(List::tr("Name: %ls\n"), bstrProviderName.raw());
1467	pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
1468	RTPrintf(List::tr("Short Name: %ls\n"), bstrProviderName.raw());
1469	Bstr bstrProviderID;
1470	pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
1471	RTPrintf("GUID: %ls\n", bstrProviderID.raw());
1472
1473	RTPrintf("\n");
1474	}
1475	return hrc;
1476	}
1477
1478
1479	/**
1480	* List all available cloud profiles (by iterating over the cloud providers).
1481	*
1482	* @returns See produceList.
1483	* @param pVirtualBox Reference to the IVirtualBox pointer.
1484	* @param fOptLong If true, list all profile properties.
1485	*/
1486	static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> &pVirtualBox, bool fOptLong)
1487	{
1488	HRESULT hrc = S_OK;
1489	ComPtr<ICloudProviderManager> pCloudProviderManager;
1490	CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1491	com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1492	CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1493
1494	for (size_t i = 0; i < apCloudProviders.size(); ++i)
1495	{
1496	ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1497	com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
1498	CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
1499	for (size_t j = 0; j < apCloudProfiles.size(); ++j)
1500	{
1501	ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
1502	Bstr bstrProfileName;
1503	pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
1504	RTPrintf(List::tr("Name: %ls\n"), bstrProfileName.raw());
1505	Bstr bstrProviderID;
1506	pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
1507	RTPrintf(List::tr("Provider GUID: %ls\n"), bstrProviderID.raw());
1508
1509	if (fOptLong)
1510	{
1511	com::SafeArray<BSTR> names;
1512	com::SafeArray<BSTR> values;
1513	pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1514	size_t cNames = names.size();
1515	size_t cValues = values.size();
1516	bool fFirst = true;
1517	for (size_t k = 0; k < cNames; k++)
1518	{
1519	Bstr value;
1520	if (k < cValues)
1521	value = values[k];
1522	RTPrintf("%s%ls=%ls\n",
1523	fFirst ? List::tr("Property: ") : " ",
1524	names[k], value.raw());
1525	fFirst = false;
1526	}
1527	}
1528
1529	RTPrintf("\n");
1530	}
1531	}
1532	return hrc;
1533	}
1534
1535	static HRESULT displayCPUProfile(ICPUProfile *pProfile, size_t idx, int cchIdx, bool fOptLong, HRESULT hrc)
1536	{
1537	/* Retrieve the attributes needed for both long and short display. */
1538	Bstr bstrName;
1539	CHECK_ERROR2I_RET(pProfile, COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1540
1541	CPUArchitecture_T enmArchitecture = CPUArchitecture_Any;
1542	CHECK_ERROR2I_RET(pProfile, COMGETTER(Architecture)(&enmArchitecture), hrcCheck);
1543	const char *pszArchitecture = "???";
1544	switch (enmArchitecture)
1545	{
1546	case CPUArchitecture_x86: pszArchitecture = "x86"; break;
1547	case CPUArchitecture_AMD64: pszArchitecture = "AMD64"; break;
1548	case CPUArchitecture_ARMv8_32: pszArchitecture = "ARMv8 (32-bit only)"; break;
1549	case CPUArchitecture_ARMv8_64: pszArchitecture = "ARMv8 (64-bit)"; break;
1550	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1551	case CPUArchitecture_32BitHack:
1552	#endif
1553	case CPUArchitecture_Any:
1554	break;
1555	}
1556
1557	/* Print what we've got. */
1558	if (!fOptLong)
1559	RTPrintf("#%0*zu: %ls [%s]\n", cchIdx, idx, bstrName.raw(), pszArchitecture);
1560	else
1561	{
1562	RTPrintf(List::tr("CPU Profile #%02zu:\n"), idx);
1563	RTPrintf(List::tr(" Architecture: %s\n"), pszArchitecture);
1564	RTPrintf(List::tr(" Name: %ls\n"), bstrName.raw());
1565	CHECK_ERROR2I_RET(pProfile, COMGETTER(FullName)(bstrName.asOutParam()), hrcCheck);
1566	RTPrintf(List::tr(" Full Name: %ls\n"), bstrName.raw());
1567	}
1568	return hrc;
1569	}
1570
1571
1572	/**
1573	* List all CPU profiles.
1574	*
1575	* @returns See produceList.
1576	* @param ptrVirtualBox Reference to the smart IVirtualBox pointer.
1577	* @param fOptLong If true, list all profile properties.
1578	* @param fOptSorted Sort the output if true, otherwise display in
1579	* system order.
1580	*/
1581	static HRESULT listCPUProfiles(const ComPtr<IVirtualBox> &ptrVirtualBox, bool fOptLong, bool fOptSorted)
1582	{
1583	ComPtr<ISystemProperties> ptrSysProps;
1584	CHECK_ERROR2I_RET(ptrVirtualBox, COMGETTER(SystemProperties)(ptrSysProps.asOutParam()), hrcCheck);
1585	com::SafeIfaceArray<ICPUProfile> aCPUProfiles;
1586	CHECK_ERROR2I_RET(ptrSysProps, GetCPUProfiles(CPUArchitecture_Any, Bstr().raw(),
1587	ComSafeArrayAsOutParam(aCPUProfiles)), hrcCheck);
1588
1589	int const cchIdx = 1 + (aCPUProfiles.size() >= 10) + (aCPUProfiles.size() >= 100);
1590
1591	HRESULT hrc = S_OK;
1592	if (!fOptSorted)
1593	for (size_t i = 0; i < aCPUProfiles.size(); i++)
1594	hrc = displayCPUProfile(aCPUProfiles[i], i, cchIdx, fOptLong, hrc);
1595	else
1596	{
1597	std::vector<std::pair<com::Bstr, ICPUProfile *> > vecSortedProfiles;
1598	for (size_t i = 0; i < aCPUProfiles.size(); ++i)
1599	{
1600	Bstr bstrName;
1601	CHECK_ERROR2I_RET(aCPUProfiles[i], COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1602	try
1603	{
1604	vecSortedProfiles.push_back(std::pair<com::Bstr, ICPUProfile *>(bstrName, aCPUProfiles[i]));
1605	}
1606	catch (std::bad_alloc &)
1607	{
1608	return E_OUTOFMEMORY;
1609	}
1610	}
1611
1612	std::sort(vecSortedProfiles.begin(), vecSortedProfiles.end());
1613
1614	for (size_t i = 0; i < vecSortedProfiles.size(); i++)
1615	hrc = displayCPUProfile(vecSortedProfiles[i].second, i, cchIdx, fOptLong, hrc);
1616	}
1617
1618	return hrc;
1619	}
1620
1621
1622	/**
1623	* Translates PartitionType_T to a string if possible.
1624	* @returns read-only string if known value, @a pszUnknown if not.
1625	*/
1626	static const char PartitionTypeToString(PartitionType_T enmType, const char pszUnknown)
1627	{
1628	#define MY_CASE_STR(a_Type) case RT_CONCAT(PartitionType_,a_Type): return #a_Type
1629	switch (enmType)
1630	{
1631	MY_CASE_STR(Empty);
1632	MY_CASE_STR(FAT12);
1633	MY_CASE_STR(FAT16);
1634	MY_CASE_STR(FAT);
1635	MY_CASE_STR(IFS);
1636	MY_CASE_STR(FAT32CHS);
1637	MY_CASE_STR(FAT32LBA);
1638	MY_CASE_STR(FAT16B);
1639	MY_CASE_STR(Extended);
1640	MY_CASE_STR(WindowsRE);
1641	MY_CASE_STR(LinuxSwapOld);
1642	MY_CASE_STR(LinuxOld);
1643	MY_CASE_STR(DragonFlyBSDSlice);
1644	MY_CASE_STR(LinuxSwap);
1645	MY_CASE_STR(Linux);
1646	MY_CASE_STR(LinuxExtended);
1647	MY_CASE_STR(LinuxLVM);
1648	MY_CASE_STR(BSDSlice);
1649	MY_CASE_STR(AppleUFS);
1650	MY_CASE_STR(AppleHFS);
1651	MY_CASE_STR(Solaris);
1652	MY_CASE_STR(GPT);
1653	MY_CASE_STR(EFI);
1654	MY_CASE_STR(Unknown);
1655	MY_CASE_STR(MBR);
1656	MY_CASE_STR(iFFS);
1657	MY_CASE_STR(SonyBoot);
1658	MY_CASE_STR(LenovoBoot);
1659	MY_CASE_STR(WindowsMSR);
1660	MY_CASE_STR(WindowsBasicData);
1661	MY_CASE_STR(WindowsLDMMeta);
1662	MY_CASE_STR(WindowsLDMData);
1663	MY_CASE_STR(WindowsRecovery);
1664	MY_CASE_STR(WindowsStorageSpaces);
1665	MY_CASE_STR(WindowsStorageReplica);
1666	MY_CASE_STR(IBMGPFS);
1667	MY_CASE_STR(LinuxData);
1668	MY_CASE_STR(LinuxRAID);
1669	MY_CASE_STR(LinuxRootX86);
1670	MY_CASE_STR(LinuxRootAMD64);
1671	MY_CASE_STR(LinuxRootARM32);
1672	MY_CASE_STR(LinuxRootARM64);
1673	MY_CASE_STR(LinuxHome);
1674	MY_CASE_STR(LinuxSrv);
1675	MY_CASE_STR(LinuxPlainDmCrypt);
1676	MY_CASE_STR(LinuxLUKS);
1677	MY_CASE_STR(LinuxReserved);
1678	MY_CASE_STR(FreeBSDBoot);
1679	MY_CASE_STR(FreeBSDData);
1680	MY_CASE_STR(FreeBSDSwap);
1681	MY_CASE_STR(FreeBSDUFS);
1682	MY_CASE_STR(FreeBSDVinum);
1683	MY_CASE_STR(FreeBSDZFS);
1684	MY_CASE_STR(FreeBSDUnknown);
1685	MY_CASE_STR(AppleHFSPlus);
1686	MY_CASE_STR(AppleAPFS);
1687	MY_CASE_STR(AppleRAID);
1688	MY_CASE_STR(AppleRAIDOffline);
1689	MY_CASE_STR(AppleBoot);
1690	MY_CASE_STR(AppleLabel);
1691	MY_CASE_STR(AppleTvRecovery);
1692	MY_CASE_STR(AppleCoreStorage);
1693	MY_CASE_STR(SoftRAIDStatus);
1694	MY_CASE_STR(SoftRAIDScratch);
1695	MY_CASE_STR(SoftRAIDVolume);
1696	MY_CASE_STR(SoftRAIDCache);
1697	MY_CASE_STR(AppleUnknown);
1698	MY_CASE_STR(SolarisBoot);
1699	MY_CASE_STR(SolarisRoot);
1700	MY_CASE_STR(SolarisSwap);
1701	MY_CASE_STR(SolarisBackup);
1702	MY_CASE_STR(SolarisUsr);
1703	MY_CASE_STR(SolarisVar);
1704	MY_CASE_STR(SolarisHome);
1705	MY_CASE_STR(SolarisAltSector);
1706	MY_CASE_STR(SolarisReserved);
1707	MY_CASE_STR(SolarisUnknown);
1708	MY_CASE_STR(NetBSDSwap);
1709	MY_CASE_STR(NetBSDFFS);
1710	MY_CASE_STR(NetBSDLFS);
1711	MY_CASE_STR(NetBSDRAID);
1712	MY_CASE_STR(NetBSDConcatenated);
1713	MY_CASE_STR(NetBSDEncrypted);
1714	MY_CASE_STR(NetBSDUnknown);
1715	MY_CASE_STR(ChromeOSKernel);
1716	MY_CASE_STR(ChromeOSRootFS);
1717	MY_CASE_STR(ChromeOSFuture);
1718	MY_CASE_STR(ContLnxUsr);
1719	MY_CASE_STR(ContLnxRoot);
1720	MY_CASE_STR(ContLnxReserved);
1721	MY_CASE_STR(ContLnxRootRAID);
1722	MY_CASE_STR(HaikuBFS);
1723	MY_CASE_STR(MidntBSDBoot);
1724	MY_CASE_STR(MidntBSDData);
1725	MY_CASE_STR(MidntBSDSwap);
1726	MY_CASE_STR(MidntBSDUFS);
1727	MY_CASE_STR(MidntBSDVium);
1728	MY_CASE_STR(MidntBSDZFS);
1729	MY_CASE_STR(MidntBSDUnknown);
1730	MY_CASE_STR(OpenBSDData);
1731	MY_CASE_STR(QNXPowerSafeFS);
1732	MY_CASE_STR(Plan9);
1733	MY_CASE_STR(VMWareVMKCore);
1734	MY_CASE_STR(VMWareVMFS);
1735	MY_CASE_STR(VMWareReserved);
1736	MY_CASE_STR(VMWareUnknown);
1737	MY_CASE_STR(AndroidX86Bootloader);
1738	MY_CASE_STR(AndroidX86Bootloader2);
1739	MY_CASE_STR(AndroidX86Boot);
1740	MY_CASE_STR(AndroidX86Recovery);
1741	MY_CASE_STR(AndroidX86Misc);
1742	MY_CASE_STR(AndroidX86Metadata);
1743	MY_CASE_STR(AndroidX86System);
1744	MY_CASE_STR(AndroidX86Cache);
1745	MY_CASE_STR(AndroidX86Data);
1746	MY_CASE_STR(AndroidX86Persistent);
1747	MY_CASE_STR(AndroidX86Vendor);
1748	MY_CASE_STR(AndroidX86Config);
1749	MY_CASE_STR(AndroidX86Factory);
1750	MY_CASE_STR(AndroidX86FactoryAlt);
1751	MY_CASE_STR(AndroidX86Fastboot);
1752	MY_CASE_STR(AndroidX86OEM);
1753	MY_CASE_STR(AndroidARMMeta);
1754	MY_CASE_STR(AndroidARMExt);
1755	MY_CASE_STR(ONIEBoot);
1756	MY_CASE_STR(ONIEConfig);
1757	MY_CASE_STR(PowerPCPrep);
1758	MY_CASE_STR(XDGShrBootConfig);
1759	MY_CASE_STR(CephBlock);
1760	MY_CASE_STR(CephBlockDB);
1761	MY_CASE_STR(CephBlockDBDmc);
1762	MY_CASE_STR(CephBlockDBDmcLUKS);
1763	MY_CASE_STR(CephBlockDmc);
1764	MY_CASE_STR(CephBlockDmcLUKS);
1765	MY_CASE_STR(CephBlockWALog);
1766	MY_CASE_STR(CephBlockWALogDmc);
1767	MY_CASE_STR(CephBlockWALogDmcLUKS);
1768	MY_CASE_STR(CephDisk);
1769	MY_CASE_STR(CephDiskDmc);
1770	MY_CASE_STR(CephJournal);
1771	MY_CASE_STR(CephJournalDmc);
1772	MY_CASE_STR(CephJournalDmcLUKS);
1773	MY_CASE_STR(CephLockbox);
1774	MY_CASE_STR(CephMultipathBlock1);
1775	MY_CASE_STR(CephMultipathBlock2);
1776	MY_CASE_STR(CephMultipathBlockDB);
1777	MY_CASE_STR(CephMultipathBLockWALog);
1778	MY_CASE_STR(CephMultipathJournal);
1779	MY_CASE_STR(CephMultipathOSD);
1780	MY_CASE_STR(CephOSD);
1781	MY_CASE_STR(CephOSDDmc);
1782	MY_CASE_STR(CephOSDDmcLUKS);
1783	#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1784	case PartitionType_32BitHack: break;
1785	#endif
1786	/* no default! */
1787	}
1788	#undef MY_CASE_STR
1789	return pszUnknown;
1790	}
1791
1792
1793	/**
1794	* List all available host drives with their partitions.
1795	*
1796	* @returns See produceList.
1797	* @param pVirtualBox Reference to the IVirtualBox pointer.
1798	* @param fOptLong Long listing or human readable.
1799	*/
1800	static HRESULT listHostDrives(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
1801	{
1802	HRESULT hrc = S_OK;
1803	ComPtr<IHost> pHost;
1804	CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), hrcCheck);
1805	com::SafeIfaceArray<IHostDrive> apHostDrives;
1806	CHECK_ERROR2I_RET(pHost, COMGETTER(HostDrives)(ComSafeArrayAsOutParam(apHostDrives)), hrcCheck);
1807	for (size_t i = 0; i < apHostDrives.size(); ++i)
1808	{
1809	ComPtr<IHostDrive> pHostDrive = apHostDrives[i];
1810
1811	/* The drivePath and model attributes are accessible even when the object
1812	is in 'limited' mode. */
1813	com::Bstr bstrDrivePath;
1814	CHECK_ERROR(pHostDrive,COMGETTER(DrivePath)(bstrDrivePath.asOutParam()));
1815	if (SUCCEEDED(hrc))
1816	RTPrintf(List::tr("%sDrive: %ls\n"), i > 0 ? "\n" : "", bstrDrivePath.raw());
1817	else
1818	RTPrintf(List::tr("%sDrive: %Rhrc\n"), i > 0 ? "\n" : "", hrc);
1819
1820	com::Bstr bstrModel;
1821	CHECK_ERROR(pHostDrive,COMGETTER(Model)(bstrModel.asOutParam()));
1822	if (FAILED(hrc))
1823	RTPrintf(List::tr("Model: %Rhrc\n"), hrc);
1824	else if (bstrModel.isNotEmpty())
1825	RTPrintf(List::tr("Model: \"%ls\"\n"), bstrModel.raw());
1826	else
1827	RTPrintf(List::tr("Model: unknown/inaccessible\n"));
1828
1829	/* The other attributes are not accessible in limited mode and will fail
1830	with E_ACCESSDENIED. Typically means the user cannot read the drive. */
1831	com::Bstr bstrUuidDisk;
1832	hrc = pHostDrive->COMGETTER(Uuid)(bstrUuidDisk.asOutParam());
1833	if (SUCCEEDED(hrc) && !com::Guid(bstrUuidDisk).isZero())
1834	RTPrintf("UUID: %ls\n", bstrUuidDisk.raw());
1835	else if (hrc == E_ACCESSDENIED)
1836	{
1837	RTPrintf(List::tr("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n"),
1838	bstrDrivePath.raw());
1839	continue;
1840	}
1841	else if (FAILED(hrc))
1842	{
1843	RTPrintf("UUID: %Rhrc\n", hrc);
1844	com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1845	}
1846
1847	LONG64 cbSize = 0;
1848	hrc = pHostDrive->COMGETTER(Size)(&cbSize);
1849	if (SUCCEEDED(hrc) && fOptLong)
1850	RTPrintf(List::tr("Size: %llu bytes (%Rhcb)\n", "", cbSize), cbSize, cbSize);
1851	else if (SUCCEEDED(hrc))
1852	RTPrintf(List::tr("Size: %Rhcb\n"), cbSize);
1853	else
1854	{
1855	RTPrintf(List::tr("Size: %Rhrc\n"), hrc);
1856	com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1857	}
1858
1859	ULONG cbSectorSize = 0;
1860	hrc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
1861	if (SUCCEEDED(hrc))
1862	RTPrintf(List::tr("Sector Size: %u bytes\n", "", cbSectorSize), cbSectorSize);
1863	else
1864	{
1865	RTPrintf(List::tr("Sector Size: %Rhrc\n"), hrc);
1866	com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1867	}
1868
1869	PartitioningType_T partitioningType = (PartitioningType_T)9999;
1870	hrc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
1871	if (SUCCEEDED(hrc))
1872	RTPrintf(List::tr("Scheme: %s\n"), partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
1873	else
1874	{
1875	RTPrintf(List::tr("Scheme: %Rhrc\n"), hrc);
1876	com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1877	}
1878
1879	com::SafeIfaceArray<IHostDrivePartition> apHostDrivesPartitions;
1880	hrc = pHostDrive->COMGETTER(Partitions)(ComSafeArrayAsOutParam(apHostDrivesPartitions));
1881	if (FAILED(hrc))
1882	{
1883	RTPrintf(List::tr("Partitions: %Rhrc\n"), hrc);
1884	com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1885	}
1886	else if (apHostDrivesPartitions.size() == 0)
1887	RTPrintf(List::tr("Partitions: None (or not able to grok them).\n"));
1888	else if (partitioningType == PartitioningType_MBR)
1889	{
1890	if (fOptLong)
1891	RTPrintf(List::tr("Partitions: First Last\n"
1892	"## Type Byte Size Byte Offset Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1893	else
1894	RTPrintf(List::tr("Partitions: First Last\n"
1895	"## Type Size Start Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1896	for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1897	{
1898	ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1899
1900	ULONG idx = 0;
1901	CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
1902	ULONG uType = 0;
1903	CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeMBR)(&uType));
1904	ULONG uStartCylinder = 0;
1905	CHECK_ERROR(pHostDrivePartition, COMGETTER(StartCylinder)(&uStartCylinder));
1906	ULONG uStartHead = 0;
1907	CHECK_ERROR(pHostDrivePartition, COMGETTER(StartHead)(&uStartHead));
1908	ULONG uStartSector = 0;
1909	CHECK_ERROR(pHostDrivePartition, COMGETTER(StartSector)(&uStartSector));
1910	ULONG uEndCylinder = 0;
1911	CHECK_ERROR(pHostDrivePartition, COMGETTER(EndCylinder)(&uEndCylinder));
1912	ULONG uEndHead = 0;
1913	CHECK_ERROR(pHostDrivePartition, COMGETTER(EndHead)(&uEndHead));
1914	ULONG uEndSector = 0;
1915	CHECK_ERROR(pHostDrivePartition, COMGETTER(EndSector)(&uEndSector));
1916	cbSize = 0;
1917	CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
1918	LONG64 offStart = 0;
1919	CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
1920	BOOL fActive = 0;
1921	CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
1922	PartitionType_T enmType = PartitionType_Unknown;
1923	CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1924
1925	/* Max size & offset here is around 16TiB with 4KiB sectors. */
1926	if (fOptLong) /* cb/off: max 16TiB; idx: max 64. */
1927	RTPrintf("%2u %02x %14llu %14llu %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1928	idx, uType, cbSize, offStart,
1929	uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1930	fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1931	else
1932	RTPrintf("%2u %02x %8Rhcb %8Rhcb %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1933	idx, uType, (uint64_t)cbSize, (uint64_t)offStart,
1934	uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1935	fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1936	}
1937	}
1938	else /* GPT */
1939	{
1940	/* Determin the max partition type length to try reduce the table width: */
1941	size_t cchMaxType = 0;
1942	for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1943	{
1944	ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1945	PartitionType_T enmType = PartitionType_Unknown;
1946	CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1947	size_t const cchTypeNm = strlen(PartitionTypeToString(enmType, "e530bf6d-2754-4e9d-b260-60a5d0b80457"));
1948	cchMaxType = RT_MAX(cchTypeNm, cchMaxType);
1949	}
1950	cchMaxType = RT_MIN(cchMaxType, RTUUID_STR_LENGTH);
1951
1952	if (fOptLong)
1953	RTPrintf(List::tr(
1954	"Partitions:\n"
1955	"## %-*s Uuid Byte Size Byte Offset Active Name\n"),
1956	(int)cchMaxType, List::tr("Type"));
1957	else
1958	RTPrintf(List::tr(
1959	"Partitions:\n"
1960	"## %-*s Uuid Size Start Active Name\n"),
1961	(int)cchMaxType, List::tr("Type"));
1962
1963	for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1964	{
1965	ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1966
1967	ULONG idx = 0;
1968	CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
1969	com::Bstr bstrUuidType;
1970	CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeUuid)(bstrUuidType.asOutParam()));
1971	com::Bstr bstrUuidPartition;
1972	CHECK_ERROR(pHostDrivePartition, COMGETTER(Uuid)(bstrUuidPartition.asOutParam()));
1973	cbSize = 0;
1974	CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
1975	LONG64 offStart = 0;
1976	CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
1977	BOOL fActive = 0;
1978	CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
1979	com::Bstr bstrName;
1980	CHECK_ERROR(pHostDrivePartition, COMGETTER(Name)(bstrName.asOutParam()));
1981
1982	PartitionType_T enmType = PartitionType_Unknown;
1983	CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1984
1985	Utf8Str strTypeConv;
1986	const char *pszTypeNm = PartitionTypeToString(enmType, NULL);
1987	if (!pszTypeNm)
1988	pszTypeNm = (strTypeConv = bstrUuidType).c_str();
1989	else if (strlen(pszTypeNm) >= RTUUID_STR_LENGTH /* includes '\0' */)
1990	pszTypeNm -= RTUUID_STR_LENGTH - 1 - strlen(pszTypeNm);
1991
1992	if (fOptLong)
1993	RTPrintf("%2u %-*s %36ls %19llu %19llu %-3s %ls\n", idx, cchMaxType, pszTypeNm,
1994	bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
1995	bstrName.raw());
1996	else
1997	RTPrintf("%2u %-*s %36ls %8Rhcb %8Rhcb %-3s %ls\n", idx, cchMaxType, pszTypeNm,
1998	bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
1999	bstrName.raw());
2000	}
2001	}
2002	}
2003	return hrc;
2004	}
2005
2006
2007	/**
2008	* The type of lists we can produce.
2009	*/
2010	enum ListType_T
2011	{
2012	kListNotSpecified = 1000,
2013	kListVMs,
2014	kListRunningVMs,
2015	kListOsTypes,
2016	kListHostDvds,
2017	kListHostFloppies,
2018	kListInternalNetworks,
2019	kListBridgedInterfaces,
2020	#if defined(VBOX_WITH_NETFLT)
2021	kListHostOnlyInterfaces,
2022	#endif
2023	#if defined(VBOX_WITH_VMNET)
2024	kListHostOnlyNetworks,
2025	#endif
2026	#if defined(VBOX_WITH_CLOUD_NET)
2027	kListCloudNetworks,
2028	#endif
2029	kListHostCpuIDs,
2030	kListHostInfo,
2031	kListHddBackends,
2032	kListHdds,
2033	kListDvds,
2034	kListFloppies,
2035	kListUsbHost,
2036	kListUsbFilters,
2037	kListSystemProperties,
2038	#if defined(VBOX_WITH_UPDATE_AGENT)
2039	kListUpdateAgents,
2040	#endif
2041	kListDhcpServers,
2042	kListExtPacks,
2043	kListGroups,
2044	kListNatNetworks,
2045	kListVideoInputDevices,
2046	kListScreenShotFormats,
2047	kListCloudProviders,
2048	kListCloudProfiles,
2049	kListCPUProfiles,
2050	kListHostDrives
2051	};
2052
2053
2054	/**
2055	* Produces the specified listing.
2056	*
2057	* @returns S_OK or some COM error code that has been reported in full.
2058	* @param enmList The list to produce.
2059	* @param fOptLong Long (@c true) or short list format.
2060	* @param pVirtualBox Reference to the IVirtualBox smart pointer.
2061	*/
2062	static HRESULT produceList(enum ListType_T enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
2063	{
2064	HRESULT hrc = S_OK;
2065	switch (enmCommand)
2066	{
2067	case kListNotSpecified:
2068	AssertFailed();
2069	return E_FAIL;
2070
2071	case kListVMs:
2072	{
2073	/*
2074	* Get the list of all registered VMs
2075	*/
2076	com::SafeIfaceArray<IMachine> machines;
2077	hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2078	if (SUCCEEDED(hrc))
2079	{
2080	/*
2081	* Display it.
2082	*/
2083	if (!fOptSorted)
2084	{
2085	for (size_t i = 0; i < machines.size(); ++i)
2086	if (machines[i])
2087	hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2088	}
2089	else
2090	{
2091	/*
2092	* Sort the list by name before displaying it.
2093	*/
2094	std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
2095	for (size_t i = 0; i < machines.size(); ++i)
2096	{
2097	IMachine *pMachine = machines[i];
2098	if (pMachine) /* no idea why we need to do this... */
2099	{
2100	Bstr bstrName;
2101	pMachine->COMGETTER(Name)(bstrName.asOutParam());
2102	sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
2103	}
2104	}
2105
2106	std::sort(sortedMachines.begin(), sortedMachines.end());
2107
2108	for (size_t i = 0; i < sortedMachines.size(); ++i)
2109	hrc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2110	}
2111	}
2112	break;
2113	}
2114
2115	case kListRunningVMs:
2116	{
2117	/*
2118	* Get the list of all _running_ VMs
2119	*/
2120	com::SafeIfaceArray<IMachine> machines;
2121	hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2122	com::SafeArray<MachineState_T> states;
2123	if (SUCCEEDED(hrc))
2124	hrc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
2125	if (SUCCEEDED(hrc))
2126	{
2127	/*
2128	* Iterate through the collection
2129	*/
2130	for (size_t i = 0; i < machines.size(); ++i)
2131	{
2132	if (machines[i])
2133	{
2134	MachineState_T machineState = states[i];
2135	switch (machineState)
2136	{
2137	case MachineState_Running:
2138	case MachineState_Teleporting:
2139	case MachineState_LiveSnapshotting:
2140	case MachineState_Paused:
2141	case MachineState_TeleportingPausedVM:
2142	hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2143	break;
2144	default: break; /* Shut up MSC */
2145	}
2146	}
2147	}
2148	}
2149	break;
2150	}
2151
2152	case kListOsTypes:
2153	{
2154	com::SafeIfaceArray<IGuestOSType> coll;
2155	hrc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
2156	if (SUCCEEDED(hrc))
2157	{
2158	/*
2159	* Iterate through the collection.
2160	*/
2161	for (size_t i = 0; i < coll.size(); ++i)
2162	{
2163	ComPtr<IGuestOSType> guestOS;
2164	guestOS = coll[i];
2165	Bstr guestId;
2166	guestOS->COMGETTER(Id)(guestId.asOutParam());
2167	RTPrintf("ID: %ls\n", guestId.raw());
2168	Bstr guestDescription;
2169	guestOS->COMGETTER(Description)(guestDescription.asOutParam());
2170	RTPrintf(List::tr("Description: %ls\n"), guestDescription.raw());
2171	Bstr familyId;
2172	guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
2173	RTPrintf(List::tr("Family ID: %ls\n"), familyId.raw());
2174	Bstr familyDescription;
2175	guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
2176	RTPrintf(List::tr("Family Desc: %ls\n"), familyDescription.raw());
2177	BOOL is64Bit;
2178	guestOS->COMGETTER(Is64Bit)(&is64Bit);
2179	RTPrintf(List::tr("64 bit: %RTbool\n"), is64Bit);
2180	RTPrintf("\n");
2181	}
2182	}
2183	break;
2184	}
2185
2186	case kListHostDvds:
2187	{
2188	ComPtr<IHost> host;
2189	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2190	com::SafeIfaceArray<IMedium> coll;
2191	CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
2192	if (SUCCEEDED(hrc))
2193	{
2194	for (size_t i = 0; i < coll.size(); ++i)
2195	{
2196	ComPtr<IMedium> dvdDrive = coll[i];
2197	Bstr uuid;
2198	dvdDrive->COMGETTER(Id)(uuid.asOutParam());
2199	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2200	Bstr location;
2201	dvdDrive->COMGETTER(Location)(location.asOutParam());
2202	RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2203	}
2204	}
2205	break;
2206	}
2207
2208	case kListHostFloppies:
2209	{
2210	ComPtr<IHost> host;
2211	CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2212	com::SafeIfaceArray<IMedium> coll;
2213	CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
2214	if (SUCCEEDED(hrc))
2215	{
2216	for (size_t i = 0; i < coll.size(); ++i)
2217	{
2218	ComPtr<IMedium> floppyDrive = coll[i];
2219	Bstr uuid;
2220	floppyDrive->COMGETTER(Id)(uuid.asOutParam());
2221	RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2222	Bstr location;
2223	floppyDrive->COMGETTER(Location)(location.asOutParam());
2224	RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2225	}
2226	}
2227	break;
2228	}
2229
2230	case kListInternalNetworks:
2231	hrc = listInternalNetworks(pVirtualBox);
2232	break;
2233
2234	case kListBridgedInterfaces:
2235	#if defined(VBOX_WITH_NETFLT)
2236	case kListHostOnlyInterfaces:
2237	#endif
2238	hrc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
2239	break;
2240
2241	#if defined(VBOX_WITH_VMNET)
2242	case kListHostOnlyNetworks:
2243	hrc = listHostOnlyNetworks(pVirtualBox);
2244	break;
2245	#endif
2246
2247	#if defined(VBOX_WITH_CLOUD_NET)
2248	case kListCloudNetworks:
2249	hrc = listCloudNetworks(pVirtualBox);
2250	break;
2251	#endif
2252	case kListHostInfo:
2253	hrc = listHostInfo(pVirtualBox);
2254	break;
2255
2256	case kListHostCpuIDs:
2257	{
2258	ComPtr<IHost> Host;
2259	CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
2260	PlatformArchitecture_T platformArch;
2261	CHECK_ERROR_BREAK(Host, COMGETTER(Architecture)(&platformArch));
2262
2263	switch (platformArch)
2264	{
2265	case PlatformArchitecture_x86:
2266	{
2267	ComPtr<IHostX86> HostX86;
2268	CHECK_ERROR_BREAK(Host, COMGETTER(X86)(HostX86.asOutParam()));
2269
2270	RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n"));
2271	ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
2272	static uint32_t const s_auCpuIdRanges[] =
2273	{
2274	UINT32_C(0x00000000), UINT32_C(0x0000007f),
2275	UINT32_C(0x80000000), UINT32_C(0x8000007f),
2276	UINT32_C(0xc0000000), UINT32_C(0xc000007f)
2277	};
2278	for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
2279	{
2280	ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
2281	CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
2282	if (cLeafs < s_auCpuIdRanges[i] \|\| cLeafs > s_auCpuIdRanges[i+1])
2283	continue;
2284	cLeafs++;
2285	for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
2286	{
2287	CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
2288	RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
2289	}
2290	}
2291
2292	break;
2293	}
2294
2295	case PlatformArchitecture_ARM:
2296	{
2297	/** @todo BUGBUG Implement this for ARM! */
2298	break;
2299	}
2300
2301	default:
2302	AssertFailed();
2303	break;
2304	}
2305	break;
2306	}
2307
2308	case kListHddBackends:
2309	hrc = listHddBackends(pVirtualBox);
2310	break;
2311
2312	case kListHdds:
2313	{
2314	com::SafeIfaceArray<IMedium> hdds;
2315	CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
2316	hrc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
2317	break;
2318	}
2319
2320	case kListDvds:
2321	{
2322	com::SafeIfaceArray<IMedium> dvds;
2323	CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
2324	hrc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
2325	break;
2326	}
2327
2328	case kListFloppies:
2329	{
2330	com::SafeIfaceArray<IMedium> floppies;
2331	CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
2332	hrc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
2333	break;
2334	}
2335
2336	case kListUsbHost:
2337	hrc = listUsbHost(pVirtualBox);
2338	break;
2339
2340	case kListUsbFilters:
2341	hrc = listUsbFilters(pVirtualBox);
2342	break;
2343
2344	case kListSystemProperties:
2345	hrc = listSystemProperties(pVirtualBox);
2346	break;
2347
2348	#ifdef VBOX_WITH_UPDATE_AGENT
2349	case kListUpdateAgents:
2350	hrc = listUpdateAgents(pVirtualBox);
2351	break;
2352	#endif
2353	case kListDhcpServers:
2354	hrc = listDhcpServers(pVirtualBox);
2355	break;
2356
2357	case kListExtPacks:
2358	hrc = listExtensionPacks(pVirtualBox);
2359	break;
2360
2361	case kListGroups:
2362	hrc = listGroups(pVirtualBox);
2363	break;
2364
2365	case kListNatNetworks:
2366	hrc = listNATNetworks(fOptLong, fOptSorted, pVirtualBox);
2367	break;
2368
2369	case kListVideoInputDevices:
2370	hrc = listVideoInputDevices(pVirtualBox);
2371	break;
2372
2373	case kListScreenShotFormats:
2374	hrc = listScreenShotFormats(pVirtualBox);
2375	break;
2376
2377	case kListCloudProviders:
2378	hrc = listCloudProviders(pVirtualBox);
2379	break;
2380
2381	case kListCloudProfiles:
2382	hrc = listCloudProfiles(pVirtualBox, fOptLong);
2383	break;
2384
2385	case kListCPUProfiles:
2386	hrc = listCPUProfiles(pVirtualBox, fOptLong, fOptSorted);
2387	break;
2388
2389	case kListHostDrives:
2390	hrc = listHostDrives(pVirtualBox, fOptLong);
2391	break;
2392	/* No default here, want gcc warnings. */
2393
2394	} /* end switch */
2395
2396	return hrc;
2397	}
2398
2399	/**
2400	* Handles the 'list' command.
2401	*
2402	* @returns Appropriate exit code.
2403	* @param a Handler argument.
2404	*/
2405	RTEXITCODE handleList(HandlerArg *a)
2406	{
2407	bool fOptLong = false;
2408	bool fOptMultiple = false;
2409	bool fOptSorted = false;
2410	bool fFirst = true;
2411	enum ListType_T enmOptCommand = kListNotSpecified;
2412	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2413
2414	static const RTGETOPTDEF s_aListOptions[] =
2415	{
2416	{ "--long", 'l', RTGETOPT_REQ_NOTHING },
2417	{ "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
2418	{ "--sorted", 's', RTGETOPT_REQ_NOTHING },
2419	{ "vms", kListVMs, RTGETOPT_REQ_NOTHING },
2420	{ "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
2421	{ "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
2422	{ "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
2423	{ "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
2424	{ "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
2425	{ "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
2426	{ "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
2427	#if defined(VBOX_WITH_NETFLT)
2428	{ "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
2429	#endif
2430	#if defined(VBOX_WITH_VMNET)
2431	{ "hostonlynets", kListHostOnlyNetworks, RTGETOPT_REQ_NOTHING },
2432	#endif
2433	#if defined(VBOX_WITH_CLOUD_NET)
2434	{ "cloudnets", kListCloudNetworks, RTGETOPT_REQ_NOTHING },
2435	#endif
2436	{ "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2437	{ "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2438	{ "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
2439	{ "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
2440	{ "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
2441	{ "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
2442	{ "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
2443	{ "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
2444	{ "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
2445	{ "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
2446	{ "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
2447	#if defined(VBOX_WITH_UPDATE_AGENT)
2448	{ "updates", kListUpdateAgents, RTGETOPT_REQ_NOTHING },
2449	#endif
2450	{ "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
2451	{ "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
2452	{ "groups", kListGroups, RTGETOPT_REQ_NOTHING },
2453	{ "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
2454	{ "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
2455	{ "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
2456	{ "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
2457	{ "cpu-profiles", kListCPUProfiles, RTGETOPT_REQ_NOTHING },
2458	{ "hostdrives", kListHostDrives, RTGETOPT_REQ_NOTHING },
2459	};
2460
2461	int ch;
2462	RTGETOPTUNION ValueUnion;
2463	RTGETOPTSTATE GetState;
2464	RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
2465	0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
2466	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2467	{
2468	switch (ch)
2469	{
2470	case 'l': /* --long */
2471	fOptLong = true;
2472	break;
2473
2474	case 's':
2475	fOptSorted = true;
2476	break;
2477
2478	case 'm':
2479	fOptMultiple = true;
2480	if (enmOptCommand == kListNotSpecified)
2481	break;
2482	ch = enmOptCommand;
2483	RT_FALL_THRU();
2484
2485	case kListVMs:
2486	case kListRunningVMs:
2487	case kListOsTypes:
2488	case kListHostDvds:
2489	case kListHostFloppies:
2490	case kListInternalNetworks:
2491	case kListBridgedInterfaces:
2492	#if defined(VBOX_WITH_NETFLT)
2493	case kListHostOnlyInterfaces:
2494	#endif
2495	#if defined(VBOX_WITH_VMNET)
2496	case kListHostOnlyNetworks:
2497	#endif
2498	#if defined(VBOX_WITH_CLOUD_NET)
2499	case kListCloudNetworks:
2500	#endif
2501	case kListHostInfo:
2502	case kListHostCpuIDs:
2503	case kListHddBackends:
2504	case kListHdds:
2505	case kListDvds:
2506	case kListFloppies:
2507	case kListUsbHost:
2508	case kListUsbFilters:
2509	case kListSystemProperties:
2510	#if defined(VBOX_WITH_UPDATE_AGENT)
2511	case kListUpdateAgents:
2512	#endif
2513	case kListDhcpServers:
2514	case kListExtPacks:
2515	case kListGroups:
2516	case kListNatNetworks:
2517	case kListVideoInputDevices:
2518	case kListScreenShotFormats:
2519	case kListCloudProviders:
2520	case kListCloudProfiles:
2521	case kListCPUProfiles:
2522	case kListHostDrives:
2523	enmOptCommand = (enum ListType_T)ch;
2524	if (fOptMultiple)
2525	{
2526	if (fFirst)
2527	fFirst = false;
2528	else
2529	RTPrintf("\n");
2530	RTPrintf("[%s]\n", ValueUnion.pDef->pszLong);
2531	HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2532	if (FAILED(hrc))
2533	rcExit = RTEXITCODE_FAILURE;
2534	}
2535	break;
2536
2537	case VINF_GETOPT_NOT_OPTION:
2538	return errorSyntax(List::tr("Unknown subcommand \"%s\"."), ValueUnion.psz);
2539
2540	default:
2541	return errorGetOpt(ch, &ValueUnion);
2542	}
2543	}
2544
2545	/*
2546	* If not in multiple list mode, we have to produce the list now.
2547	*/
2548	if (enmOptCommand == kListNotSpecified)
2549	return errorSyntax(List::tr("Missing subcommand for \"list\" command.\n"));
2550	if (!fOptMultiple)
2551	{
2552	HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2553	if (FAILED(hrc))
2554	rcExit = RTEXITCODE_FAILURE;
2555	}
2556
2557	return rcExit;
2558	}
2559
2560	/* 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@ 101128

Download in other formats: