VBoxManageList.cpp@ 73659

Last change on this file since 73659 was 72976, checked in by vboxsync, 6 years ago
VBoxManage: XPCOM/C++ enum exorcism. Found a enum type mismatch in handleCloneMedium and fixed it as best I could.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.4 KB

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

Download in other formats: