VBoxManageList.cpp@ 75819

Last change on this file since 75819 was 75819, checked in by vboxsync, 6 years ago
Main/DHCPServer: (bugref:9288) Allow removal of DHCP options, show options when listing DHCP servers.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.9 KB

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

Download in other formats: