VBoxManageList.cpp@ 79798

Last change on this file since 79798 was 79778, checked in by vboxsync, 6 years ago
Main: s/DHCPOptionEncoding_Legacy/DHCPOptionEncoding_Normal/g as 'Legacy' does not seem a good fit for the more userfriendly value encoding. bugref:9288
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 69.8 KB

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

Download in other formats: