VirtualBox

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

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year
  • 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 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'list' command.
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef VBOX_ONLY_DOCS
19
20
21/*********************************************************************************************************************************
22* Header Files *
23*********************************************************************************************************************************/
24#include <VBox/com/com.h>
25#include <VBox/com/string.h>
26#include <VBox/com/Guid.h>
27#include <VBox/com/array.h>
28#include <VBox/com/ErrorInfo.h>
29#include <VBox/com/errorprint.h>
30
31#include <VBox/com/VirtualBox.h>
32
33#include <VBox/log.h>
34#include <iprt/stream.h>
35#include <iprt/string.h>
36#include <iprt/time.h>
37#include <iprt/getopt.h>
38#include <iprt/ctype.h>
39
40#include <vector>
41#include <algorithm>
42
43#include "VBoxManage.h"
44using namespace com;
45
46#ifdef VBOX_WITH_HOSTNETIF_API
47static 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
62static 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
77static 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 */
104static 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 */
125static 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 */
203static 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 */
288static 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 */
324static 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 */
414static 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 */
549static 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 */
622static 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 */
786static 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 NIC %d of '%ls':\n", uSlot + 1, vmName.raw());
799 for (size_t i = 0; i < options.size(); ++i)
800 RTPrintf(" %ls\n", options[i]);
801
802 return S_OK;
803}
804
805
806/**
807 * List DHCP servers.
808 *
809 * @returns See produceList.
810 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
811 */
812static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox)
813{
814 HRESULT rc = S_OK;
815 com::SafeIfaceArray<IDHCPServer> svrs;
816 CHECK_ERROR_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)), rc);
817 for (size_t i = 0; i < svrs.size(); ++i)
818 {
819 ComPtr<IDHCPServer> svr = svrs[i];
820 Bstr netName;
821 svr->COMGETTER(NetworkName)(netName.asOutParam());
822 RTPrintf("NetworkName: %ls\n", netName.raw());
823 Bstr ip;
824 svr->COMGETTER(IPAddress)(ip.asOutParam());
825 RTPrintf("IP: %ls\n", ip.raw());
826 Bstr netmask;
827 svr->COMGETTER(NetworkMask)(netmask.asOutParam());
828 RTPrintf("NetworkMask: %ls\n", netmask.raw());
829 Bstr lowerIp;
830 svr->COMGETTER(LowerIP)(lowerIp.asOutParam());
831 RTPrintf("lowerIPAddress: %ls\n", lowerIp.raw());
832 Bstr upperIp;
833 svr->COMGETTER(UpperIP)(upperIp.asOutParam());
834 RTPrintf("upperIPAddress: %ls\n", upperIp.raw());
835 BOOL fEnabled;
836 svr->COMGETTER(Enabled)(&fEnabled);
837 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
838 com::SafeArray<BSTR> globalOptions;
839 CHECK_ERROR_BREAK(svr, COMGETTER(GlobalOptions)(ComSafeArrayAsOutParam(globalOptions)));
840 if (globalOptions.size())
841 {
842 RTPrintf("Global options:\n");
843 for (size_t j = 0; j < globalOptions.size(); ++j)
844 RTPrintf(" %ls\n", globalOptions[j]);
845 }
846 com::SafeArray<BSTR> vmConfigs;
847 CHECK_ERROR_BREAK(svr, COMGETTER(VmConfigs)(ComSafeArrayAsOutParam(vmConfigs)));
848 for (size_t j = 0; j < vmConfigs.size(); ++j)
849 {
850 rc = listVmSlotDhcpOptions(svr, vmConfigs[j]);
851 if (FAILED(rc))
852 break;
853 }
854 RTPrintf("\n");
855 }
856
857 return rc;
858}
859
860/**
861 * List extension packs.
862 *
863 * @returns See produceList.
864 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
865 */
866static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
867{
868 ComObjPtr<IExtPackManager> ptrExtPackMgr;
869 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
870
871 SafeIfaceArray<IExtPack> extPacks;
872 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
873 RTPrintf("Extension Packs: %u\n", extPacks.size());
874
875 HRESULT hrc = S_OK;
876 for (size_t i = 0; i < extPacks.size(); i++)
877 {
878 /* Read all the properties. */
879 Bstr bstrName;
880 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
881 Bstr bstrDesc;
882 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
883 Bstr bstrVersion;
884 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
885 ULONG uRevision;
886 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
887 Bstr bstrEdition;
888 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
889 Bstr bstrVrdeModule;
890 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
891 BOOL fUsable;
892 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
893 Bstr bstrWhy;
894 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
895
896 /* Display them. */
897 if (i)
898 RTPrintf("\n");
899 RTPrintf("Pack no.%2zu: %ls\n"
900 "Version: %ls\n"
901 "Revision: %u\n"
902 "Edition: %ls\n"
903 "Description: %ls\n"
904 "VRDE Module: %ls\n"
905 "Usable: %RTbool\n"
906 "Why unusable: %ls\n",
907 i, bstrName.raw(),
908 bstrVersion.raw(),
909 uRevision,
910 bstrEdition.raw(),
911 bstrDesc.raw(),
912 bstrVrdeModule.raw(),
913 fUsable != FALSE,
914 bstrWhy.raw());
915
916 /* Query plugins and display them. */
917 }
918 return hrc;
919}
920
921
922/**
923 * List machine groups.
924 *
925 * @returns See produceList.
926 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
927 */
928static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
929{
930 SafeArray<BSTR> groups;
931 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
932
933 for (size_t i = 0; i < groups.size(); i++)
934 {
935 RTPrintf("\"%ls\"\n", groups[i]);
936 }
937 return S_OK;
938}
939
940
941/**
942 * List video capture devices.
943 *
944 * @returns See produceList.
945 * @param pVirtualBox Reference to the IVirtualBox pointer.
946 */
947static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox)
948{
949 HRESULT rc;
950 ComPtr<IHost> host;
951 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
952 com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
953 CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
954 RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size());
955 for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
956 {
957 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
958 Bstr name;
959 p->COMGETTER(Name)(name.asOutParam());
960 Bstr path;
961 p->COMGETTER(Path)(path.asOutParam());
962 Bstr alias;
963 p->COMGETTER(Alias)(alias.asOutParam());
964 RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
965 }
966 return rc;
967}
968
969/**
970 * List supported screen shot formats.
971 *
972 * @returns See produceList.
973 * @param pVirtualBox Reference to the IVirtualBox pointer.
974 */
975static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> pVirtualBox)
976{
977 HRESULT rc = S_OK;
978 ComPtr<ISystemProperties> systemProperties;
979 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
980 com::SafeArray<BitmapFormat_T> formats;
981 CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
982
983 RTPrintf("Supported %d screen shot formats:\n", formats.size());
984 for (size_t i = 0; i < formats.size(); ++i)
985 {
986 uint32_t u32Format = (uint32_t)formats[i];
987 char szFormat[5];
988 szFormat[0] = RT_BYTE1(u32Format);
989 szFormat[1] = RT_BYTE2(u32Format);
990 szFormat[2] = RT_BYTE3(u32Format);
991 szFormat[3] = RT_BYTE4(u32Format);
992 szFormat[4] = 0;
993 RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
994 }
995 return rc;
996}
997
998/**
999 * List available cloud providers.
1000 *
1001 * @returns See produceList.
1002 * @param pVirtualBox Reference to the IVirtualBox pointer.
1003 */
1004static HRESULT listCloudProviders(const ComPtr<IVirtualBox> pVirtualBox)
1005{
1006 HRESULT rc = S_OK;
1007 ComPtr<ICloudProviderManager> pCloudProviderManager;
1008 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1009 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1010 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1011
1012 RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size());
1013 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1014 {
1015 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1016 Bstr bstrProviderName;
1017 pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
1018 RTPrintf("Name: %ls\n", bstrProviderName.raw());
1019 pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
1020 RTPrintf("Short Name: %ls\n", bstrProviderName.raw());
1021 Bstr bstrProviderID;
1022 pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
1023 RTPrintf("GUID: %ls\n", bstrProviderID.raw());
1024
1025 RTPrintf("\n");
1026 }
1027 return rc;
1028}
1029
1030
1031/**
1032 * List all available cloud profiles (by iterating over the cloud providers).
1033 *
1034 * @returns See produceList.
1035 * @param pVirtualBox Reference to the IVirtualBox pointer.
1036 * @param fOptLong If true, list all profile properties.
1037 */
1038static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
1039{
1040 HRESULT rc = S_OK;
1041 ComPtr<ICloudProviderManager> pCloudProviderManager;
1042 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1043 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1044 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1045
1046 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1047 {
1048 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1049 com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
1050 CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
1051 for (size_t j = 0; j < apCloudProfiles.size(); ++j)
1052 {
1053 ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
1054 Bstr bstrProfileName;
1055 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
1056 RTPrintf("Name: %ls\n", bstrProfileName.raw());
1057 Bstr bstrProviderID;
1058 pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
1059 RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
1060
1061 if (fOptLong)
1062 {
1063 com::SafeArray<BSTR> names;
1064 com::SafeArray<BSTR> values;
1065 pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1066 size_t cNames = names.size();
1067 size_t cValues = values.size();
1068 bool fFirst = true;
1069 for (size_t k = 0; k < cNames; k++)
1070 {
1071 Bstr value;
1072 if (k < cValues)
1073 value = values[k];
1074 RTPrintf("%s%ls=%ls\n",
1075 fFirst ? "Property: " : " ",
1076 names[k], value.raw());
1077 fFirst = false;
1078 }
1079 }
1080
1081 RTPrintf("\n");
1082 }
1083 }
1084 return rc;
1085}
1086
1087
1088/**
1089 * The type of lists we can produce.
1090 */
1091enum enmListType
1092{
1093 kListNotSpecified = 1000,
1094 kListVMs,
1095 kListRunningVMs,
1096 kListOsTypes,
1097 kListHostDvds,
1098 kListHostFloppies,
1099 kListInternalNetworks,
1100 kListBridgedInterfaces,
1101#if defined(VBOX_WITH_NETFLT)
1102 kListHostOnlyInterfaces,
1103#endif
1104 kListHostCpuIDs,
1105 kListHostInfo,
1106 kListHddBackends,
1107 kListHdds,
1108 kListDvds,
1109 kListFloppies,
1110 kListUsbHost,
1111 kListUsbFilters,
1112 kListSystemProperties,
1113 kListDhcpServers,
1114 kListExtPacks,
1115 kListGroups,
1116 kListNatNetworks,
1117 kListVideoInputDevices,
1118 kListScreenShotFormats,
1119 kListCloudProviders,
1120 kListCloudProfiles,
1121};
1122
1123
1124/**
1125 * Produces the specified listing.
1126 *
1127 * @returns S_OK or some COM error code that has been reported in full.
1128 * @param enmList The list to produce.
1129 * @param fOptLong Long (@c true) or short list format.
1130 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1131 */
1132static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
1133{
1134 HRESULT rc = S_OK;
1135 switch (enmCommand)
1136 {
1137 case kListNotSpecified:
1138 AssertFailed();
1139 return E_FAIL;
1140
1141 case kListVMs:
1142 {
1143 /*
1144 * Get the list of all registered VMs
1145 */
1146 com::SafeIfaceArray<IMachine> machines;
1147 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1148 if (SUCCEEDED(rc))
1149 {
1150 /*
1151 * Display it.
1152 */
1153 if (!fOptSorted)
1154 {
1155 for (size_t i = 0; i < machines.size(); ++i)
1156 if (machines[i])
1157 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1158 }
1159 else
1160 {
1161 /*
1162 * Sort the list by name before displaying it.
1163 */
1164 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
1165 for (size_t i = 0; i < machines.size(); ++i)
1166 {
1167 IMachine *pMachine = machines[i];
1168 if (pMachine) /* no idea why we need to do this... */
1169 {
1170 Bstr bstrName;
1171 pMachine->COMGETTER(Name)(bstrName.asOutParam());
1172 sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
1173 }
1174 }
1175
1176 std::sort(sortedMachines.begin(), sortedMachines.end());
1177
1178 for (size_t i = 0; i < sortedMachines.size(); ++i)
1179 rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1180 }
1181 }
1182 break;
1183 }
1184
1185 case kListRunningVMs:
1186 {
1187 /*
1188 * Get the list of all _running_ VMs
1189 */
1190 com::SafeIfaceArray<IMachine> machines;
1191 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1192 com::SafeArray<MachineState_T> states;
1193 if (SUCCEEDED(rc))
1194 rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
1195 if (SUCCEEDED(rc))
1196 {
1197 /*
1198 * Iterate through the collection
1199 */
1200 for (size_t i = 0; i < machines.size(); ++i)
1201 {
1202 if (machines[i])
1203 {
1204 MachineState_T machineState = states[i];
1205 switch (machineState)
1206 {
1207 case MachineState_Running:
1208 case MachineState_Teleporting:
1209 case MachineState_LiveSnapshotting:
1210 case MachineState_Paused:
1211 case MachineState_TeleportingPausedVM:
1212 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1213 break;
1214 default: break; /* Shut up MSC */
1215 }
1216 }
1217 }
1218 }
1219 break;
1220 }
1221
1222 case kListOsTypes:
1223 {
1224 com::SafeIfaceArray<IGuestOSType> coll;
1225 rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
1226 if (SUCCEEDED(rc))
1227 {
1228 /*
1229 * Iterate through the collection.
1230 */
1231 for (size_t i = 0; i < coll.size(); ++i)
1232 {
1233 ComPtr<IGuestOSType> guestOS;
1234 guestOS = coll[i];
1235 Bstr guestId;
1236 guestOS->COMGETTER(Id)(guestId.asOutParam());
1237 RTPrintf("ID: %ls\n", guestId.raw());
1238 Bstr guestDescription;
1239 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
1240 RTPrintf("Description: %ls\n", guestDescription.raw());
1241 Bstr familyId;
1242 guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
1243 RTPrintf("Family ID: %ls\n", familyId.raw());
1244 Bstr familyDescription;
1245 guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
1246 RTPrintf("Family Desc: %ls\n", familyDescription.raw());
1247 BOOL is64Bit;
1248 guestOS->COMGETTER(Is64Bit)(&is64Bit);
1249 RTPrintf("64 bit: %RTbool\n", is64Bit);
1250 RTPrintf("\n");
1251 }
1252 }
1253 break;
1254 }
1255
1256 case kListHostDvds:
1257 {
1258 ComPtr<IHost> host;
1259 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1260 com::SafeIfaceArray<IMedium> coll;
1261 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
1262 if (SUCCEEDED(rc))
1263 {
1264 for (size_t i = 0; i < coll.size(); ++i)
1265 {
1266 ComPtr<IMedium> dvdDrive = coll[i];
1267 Bstr uuid;
1268 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
1269 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1270 Bstr location;
1271 dvdDrive->COMGETTER(Location)(location.asOutParam());
1272 RTPrintf("Name: %ls\n\n", location.raw());
1273 }
1274 }
1275 break;
1276 }
1277
1278 case kListHostFloppies:
1279 {
1280 ComPtr<IHost> host;
1281 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1282 com::SafeIfaceArray<IMedium> coll;
1283 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
1284 if (SUCCEEDED(rc))
1285 {
1286 for (size_t i = 0; i < coll.size(); ++i)
1287 {
1288 ComPtr<IMedium> floppyDrive = coll[i];
1289 Bstr uuid;
1290 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
1291 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1292 Bstr location;
1293 floppyDrive->COMGETTER(Location)(location.asOutParam());
1294 RTPrintf("Name: %ls\n\n", location.raw());
1295 }
1296 }
1297 break;
1298 }
1299
1300 case kListInternalNetworks:
1301 rc = listInternalNetworks(pVirtualBox);
1302 break;
1303
1304 case kListBridgedInterfaces:
1305#if defined(VBOX_WITH_NETFLT)
1306 case kListHostOnlyInterfaces:
1307#endif
1308 rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
1309 break;
1310
1311 case kListHostInfo:
1312 rc = listHostInfo(pVirtualBox);
1313 break;
1314
1315 case kListHostCpuIDs:
1316 {
1317 ComPtr<IHost> Host;
1318 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
1319
1320 RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
1321 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
1322 static uint32_t const s_auCpuIdRanges[] =
1323 {
1324 UINT32_C(0x00000000), UINT32_C(0x0000007f),
1325 UINT32_C(0x80000000), UINT32_C(0x8000007f),
1326 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
1327 };
1328 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
1329 {
1330 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
1331 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
1332 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
1333 continue;
1334 cLeafs++;
1335 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
1336 {
1337 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
1338 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
1339 }
1340 }
1341 break;
1342 }
1343
1344 case kListHddBackends:
1345 rc = listHddBackends(pVirtualBox);
1346 break;
1347
1348 case kListHdds:
1349 {
1350 com::SafeIfaceArray<IMedium> hdds;
1351 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
1352 rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
1353 break;
1354 }
1355
1356 case kListDvds:
1357 {
1358 com::SafeIfaceArray<IMedium> dvds;
1359 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
1360 rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
1361 break;
1362 }
1363
1364 case kListFloppies:
1365 {
1366 com::SafeIfaceArray<IMedium> floppies;
1367 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
1368 rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
1369 break;
1370 }
1371
1372 case kListUsbHost:
1373 rc = listUsbHost(pVirtualBox);
1374 break;
1375
1376 case kListUsbFilters:
1377 rc = listUsbFilters(pVirtualBox);
1378 break;
1379
1380 case kListSystemProperties:
1381 rc = listSystemProperties(pVirtualBox);
1382 break;
1383
1384 case kListDhcpServers:
1385 rc = listDhcpServers(pVirtualBox);
1386 break;
1387
1388 case kListExtPacks:
1389 rc = listExtensionPacks(pVirtualBox);
1390 break;
1391
1392 case kListGroups:
1393 rc = listGroups(pVirtualBox);
1394 break;
1395
1396 case kListNatNetworks:
1397 {
1398 com::SafeIfaceArray<INATNetwork> nets;
1399 CHECK_ERROR(pVirtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nets)));
1400 for (size_t i = 0; i < nets.size(); ++i)
1401 {
1402 ComPtr<INATNetwork> net = nets[i];
1403 Bstr netName;
1404 net->COMGETTER(NetworkName)(netName.asOutParam());
1405 RTPrintf("NetworkName: %ls\n", netName.raw());
1406 Bstr gateway;
1407 net->COMGETTER(Gateway)(gateway.asOutParam());
1408 RTPrintf("IP: %ls\n", gateway.raw());
1409 Bstr network;
1410 net->COMGETTER(Network)(network.asOutParam());
1411 RTPrintf("Network: %ls\n", network.raw());
1412 BOOL fEnabled;
1413 net->COMGETTER(IPv6Enabled)(&fEnabled);
1414 RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No");
1415 Bstr ipv6prefix;
1416 net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
1417 RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw());
1418 net->COMGETTER(NeedDhcpServer)(&fEnabled);
1419 RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No");
1420 net->COMGETTER(Enabled)(&fEnabled);
1421 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1422
1423#define PRINT_STRING_ARRAY(title) \
1424 if (strs.size() > 0) \
1425 { \
1426 RTPrintf(title); \
1427 size_t j = 0; \
1428 for (;j < strs.size(); ++j) \
1429 RTPrintf(" %s\n", Utf8Str(strs[j]).c_str()); \
1430 }
1431
1432 com::SafeArray<BSTR> strs;
1433
1434 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs)));
1435 PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n");
1436 strs.setNull();
1437
1438 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs)));
1439 PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n");
1440 strs.setNull();
1441
1442 CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs)));
1443 PRINT_STRING_ARRAY("loopback mappings (ipv4)\n");
1444 strs.setNull();
1445
1446#undef PRINT_STRING_ARRAY
1447 RTPrintf("\n");
1448 }
1449 break;
1450 }
1451
1452 case kListVideoInputDevices:
1453 rc = listVideoInputDevices(pVirtualBox);
1454 break;
1455
1456 case kListScreenShotFormats:
1457 rc = listScreenShotFormats(pVirtualBox);
1458 break;
1459
1460 case kListCloudProviders:
1461 rc = listCloudProviders(pVirtualBox);
1462 break;
1463
1464 case kListCloudProfiles:
1465 rc = listCloudProfiles(pVirtualBox, fOptLong);
1466 break;
1467
1468 /* No default here, want gcc warnings. */
1469
1470 } /* end switch */
1471
1472 return rc;
1473}
1474
1475/**
1476 * Handles the 'list' command.
1477 *
1478 * @returns Appropriate exit code.
1479 * @param a Handler argument.
1480 */
1481RTEXITCODE handleList(HandlerArg *a)
1482{
1483 bool fOptLong = false;
1484 bool fOptMultiple = false;
1485 bool fOptSorted = false;
1486 enum enmListType enmOptCommand = kListNotSpecified;
1487
1488 static const RTGETOPTDEF s_aListOptions[] =
1489 {
1490 { "--long", 'l', RTGETOPT_REQ_NOTHING },
1491 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
1492 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
1493 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
1494 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
1495 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
1496 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
1497 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
1498 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
1499 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
1500 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
1501#if defined(VBOX_WITH_NETFLT)
1502 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
1503#endif
1504 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1505 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1506 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
1507 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
1508 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
1509 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
1510 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
1511 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
1512 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
1513 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
1514 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
1515 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
1516 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
1517 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
1518 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
1519 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
1520 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
1521 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
1522 };
1523
1524 int ch;
1525 RTGETOPTUNION ValueUnion;
1526 RTGETOPTSTATE GetState;
1527 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
1528 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1529 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1530 {
1531 switch (ch)
1532 {
1533 case 'l': /* --long */
1534 fOptLong = true;
1535 break;
1536
1537 case 's':
1538 fOptSorted = true;
1539 break;
1540
1541 case 'm':
1542 fOptMultiple = true;
1543 if (enmOptCommand == kListNotSpecified)
1544 break;
1545 ch = enmOptCommand;
1546 RT_FALL_THRU();
1547
1548 case kListVMs:
1549 case kListRunningVMs:
1550 case kListOsTypes:
1551 case kListHostDvds:
1552 case kListHostFloppies:
1553 case kListInternalNetworks:
1554 case kListBridgedInterfaces:
1555#if defined(VBOX_WITH_NETFLT)
1556 case kListHostOnlyInterfaces:
1557#endif
1558 case kListHostInfo:
1559 case kListHostCpuIDs:
1560 case kListHddBackends:
1561 case kListHdds:
1562 case kListDvds:
1563 case kListFloppies:
1564 case kListUsbHost:
1565 case kListUsbFilters:
1566 case kListSystemProperties:
1567 case kListDhcpServers:
1568 case kListExtPacks:
1569 case kListGroups:
1570 case kListNatNetworks:
1571 case kListVideoInputDevices:
1572 case kListScreenShotFormats:
1573 case kListCloudProviders:
1574 case kListCloudProfiles:
1575 enmOptCommand = (enum enmListType)ch;
1576 if (fOptMultiple)
1577 {
1578 HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox);
1579 if (FAILED(hrc))
1580 return RTEXITCODE_FAILURE;
1581 }
1582 break;
1583
1584 case VINF_GETOPT_NOT_OPTION:
1585 return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
1586
1587 default:
1588 return errorGetOpt(USAGE_LIST, ch, &ValueUnion);
1589 }
1590 }
1591
1592 /*
1593 * If not in multiple list mode, we have to produce the list now.
1594 */
1595 if (enmOptCommand == kListNotSpecified)
1596 return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
1597 if (!fOptMultiple)
1598 {
1599 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
1600 if (FAILED(hrc))
1601 return RTEXITCODE_FAILURE;
1602 }
1603
1604 return RTEXITCODE_SUCCESS;
1605}
1606
1607#endif /* !VBOX_ONLY_DOCS */
1608/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette