VirtualBox

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

Last change on this file since 78296 was 76553, checked in by vboxsync, 5 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
RevLine 
[12599]1/* $Id: VBoxManageList.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
[1]2/** @file
[14732]3 * VBoxManage - The 'list' command.
[1]4 */
5
6/*
[76553]7 * Copyright (C) 2006-2019 Oracle Corporation
[1]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
[5999]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.
[1]16 */
17
[14555]18#ifndef VBOX_ONLY_DOCS
[1]19
[57358]20
21/*********************************************************************************************************************************
22* Header Files *
23*********************************************************************************************************************************/
[1]24#include <VBox/com/com.h>
25#include <VBox/com/string.h>
26#include <VBox/com/Guid.h>
[7379]27#include <VBox/com/array.h>
[1]28#include <VBox/com/ErrorInfo.h>
[20928]29#include <VBox/com/errorprint.h>
[1]30
31#include <VBox/com/VirtualBox.h>
32
[14612]33#include <VBox/log.h>
[1]34#include <iprt/stream.h>
35#include <iprt/string.h>
[14612]36#include <iprt/time.h>
[17078]37#include <iprt/getopt.h>
[18108]38#include <iprt/ctype.h>
[1]39
[65517]40#include <vector>
41#include <algorithm>
42
[1]43#include "VBoxManage.h"
44using namespace com;
45
[15235]46#ifdef VBOX_WITH_HOSTNETIF_API
[17322]47static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
[15235]48{
49 switch (enmType)
50 {
[17275]51 case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
52 case HostNetworkInterfaceMediumType_PPP: return "PPP";
53 case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
[63300]54 case HostNetworkInterfaceMediumType_Unknown: return "Unknown";
[72976]55#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
56 case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
57#endif
[15235]58 }
[63300]59 return "unknown";
[15235]60}
[15372]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";
[63300]68 case HostNetworkInterfaceStatus_Unknown: return "Unknown";
[72976]69#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
70 case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
71#endif
[15372]72 }
[63300]73 return "unknown";
[15372]74}
[33759]75#endif /* VBOX_WITH_HOSTNETIF_API */
[1]76
[33524]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";
[63300]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";
[72976]90#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
91 case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
92#endif
[33524]93 }
94 return "Unknown";
95}
96
[42748]97
98/**
[48538]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/**
[42748]118 * List network interfaces information (bridged/host only).
119 *
120 * @returns See produceList.
121 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
[48538]122 * @param fIsBridged Selects between listing host interfaces (for
123 * use with bridging) or host only interfaces.
[42748]124 */
125static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox,
126 bool fIsBridged)
[27916]127{
128 HRESULT rc;
[42748]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
[63404]140 RT_NOREF(fIsBridged);
[42748]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));
[69164]182 BOOL fWireless;
183 networkInterface->COMGETTER(Wireless)(&fWireless);
184 RTPrintf("Wireless: %s\n", fWireless ? "Yes" : "No");
[42748]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{
[60684]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 };
[42748]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);
[48765]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);
[60684]241 for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
242 {
243 BOOL supported;
[60685]244 CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
[60684]245 RTPrintf("Processor supports %s: %s\n", features[i].pszName, supported ? "yes" : "no");
246 }
[42748]247 for (ULONG i = 0; i < processorCount; i++)
248 {
[60684]249 ULONG processorSpeed = 0;
[42748]250 CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
251 if (processorSpeed)
252 RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
253 else
[43876]254 RTPrintf("Processor#%u speed: unknown\n", i);
[60684]255 Bstr processorDescription;
[42748]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.
[44498]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.
[42748]287 */
288static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
289 const com::SafeIfaceArray<IMedium> &aMedia,
[44498]290 const char *pszParentUUIDStr,
291 bool fOptLong)
[42748]292{
293 HRESULT rc = S_OK;
[28249]294 for (size_t i = 0; i < aMedia.size(); ++i)
[27916]295 {
[29356]296 ComPtr<IMedium> pMedium = aMedia[i];
[27916]297
[44498]298 rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
[27916]299
300 RTPrintf("\n");
301
302 com::SafeIfaceArray<IMedium> children;
[29356]303 CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
[27916]304 if (children.size() > 0)
305 {
[44498]306 Bstr uuid;
307 pMedium->COMGETTER(Id)(uuid.asOutParam());
308
[27916]309 // depth first listing of child media
[44498]310 rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
[27916]311 }
312 }
[42748]313
314 return rc;
[27916]315}
316
[33766]317
[33759]318/**
[42748]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],
[45065]341 COMGETTER(Name)(description.asOutParam()));
[42748]342
[44503]343 ULONG caps = 0;
344 com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
[42748]345 CHECK_ERROR(mediumFormats[i],
[44503]346 COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)));
347 for (ULONG j = 0; j < mediumFormatCap.size(); j++)
348 caps |= mediumFormatCap[j];
[42748]349
[44503]350
[42748]351 RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
352 i, id.raw(), description.raw(), caps);
353
354 /* File extensions */
[48538]355 com::SafeArray<BSTR> fileExtensions;
356 com::SafeArray<DeviceType_T> deviceTypes;
[42748]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 */
[48538]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;
[42748]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;
[72976]392#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
393 case DataType_32BitHack: break; /* Shut up compiler warnings. */
394#endif
[42748]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 {
[47908]433 ComPtr<IHostUSBDevice> dev = CollPtr[i];
[42748]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);
[53297]450 USBConnectionSpeed_T enmSpeed;
451 CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
[42748]452
453 RTPrintf("UUID: %s\n"
454 "VendorId: %#06x (%04X)\n"
455 "ProductId: %#06x (%04X)\n"
456 "Revision: %u.%u (%02u%02u)\n"
[53297]457 "Port: %u\n",
[42748]458 Utf8Str(id).c_str(),
459 usVendorId, usVendorId, usProductId, usProductId,
460 bcdRevision >> 8, bcdRevision & 0xff,
461 bcdRevision >> 8, bcdRevision & 0xff,
[53297]462 usPort);
[42748]463
[53297]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
[42748]489 /* optional stuff. */
[59398]490 SafeArray<BSTR> CollDevInfo;
[42748]491 Bstr bstr;
[59398]492 CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1);
493 if (CollDevInfo.size() >= 1)
494 bstr = Bstr(CollDevInfo[0]);
[42748]495 if (!bstr.isEmpty())
496 RTPrintf("Manufacturer: %ls\n", bstr.raw());
[59398]497 if (CollDevInfo.size() >= 2)
498 bstr = Bstr(CollDevInfo[1]);
[42748]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;
[74431]625 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
[42748]626
627 Bstr str;
628 ULONG ulValue;
629 LONG64 i64Value;
[47991]630 BOOL fValue;
[61577]631 const char *psz;
[42748]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);
[46116]644 systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
645 RTPrintf("Maximum guest monitor count: %u\n", ulValue);
[42748]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);
[64910]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);
[42748]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);
[46116]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
[42748]720 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
721 RTPrintf("Default machine folder: %ls\n", str.raw());
[56372]722 systemProperties->COMGETTER(RawModeSupported)(&fValue);
723 RTPrintf("Raw-mode Supported: %s\n", fValue ? "yes" : "no");
[47991]724 systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
[56372]725 RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off");
[46122]726 systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
[46116]727 RTPrintf("Default hard disk format: %ls\n", str.raw());
[42748]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);
[46116]736 systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
737 RTPrintf("Default frontend: %ls\n", str.raw());
[61577]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);
[42748]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());
[55843]758 systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
759 RTPrintf("Logging Level: %ls\n", str.raw());
[74431]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;
[74432]768#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
769 case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */
770#endif
[74431]771 }
772 RTPrintf("Proxy Mode: %s\n", psz);
773 systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
774 RTPrintf("Proxy URL: %ls\n", str.raw());
[42748]775 return S_OK;
776}
777
778
779/**
[75819]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())
[75918]798 RTPrintf("Options for NIC %d of '%ls':\n", uSlot + 1, vmName.raw());
[75819]799 for (size_t i = 0; i < options.size(); ++i)
800 RTPrintf(" %ls\n", options[i]);
[75850]801
[75819]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/**
[33766]861 * List extension packs.
862 *
863 * @returns See produceList.
[42748]864 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
[33766]865 */
[42748]866static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
[33766]867{
868 ComObjPtr<IExtPackManager> ptrExtPackMgr;
[56118]869 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
[33766]870
871 SafeIfaceArray<IExtPack> extPacks;
[56118]872 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
[33766]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. */
[42748]879 Bstr bstrName;
[56118]880 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
[42748]881 Bstr bstrDesc;
[56118]882 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
[42748]883 Bstr bstrVersion;
[56118]884 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
[42748]885 ULONG uRevision;
[56118]886 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
[42748]887 Bstr bstrEdition;
[56118]888 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
[42748]889 Bstr bstrVrdeModule;
[56118]890 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
[42748]891 BOOL fUsable;
[56118]892 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
[42748]893 Bstr bstrWhy;
[56118]894 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
[33766]895
896 /* Display them. */
897 if (i)
898 RTPrintf("\n");
[38735]899 RTPrintf("Pack no.%2zu: %ls\n"
900 "Version: %ls\n"
[33766]901 "Revision: %u\n"
[39662]902 "Edition: %ls\n"
[38735]903 "Description: %ls\n"
904 "VRDE Module: %ls\n"
[33766]905 "Usable: %RTbool\n"
[38735]906 "Why unusable: %ls\n",
[33766]907 i, bstrName.raw(),
908 bstrVersion.raw(),
909 uRevision,
[39662]910 bstrEdition.raw(),
[33766]911 bstrDesc.raw(),
[34244]912 bstrVrdeModule.raw(),
[33766]913 fUsable != FALSE,
914 bstrWhy.raw());
[34244]915
916 /* Query plugins and display them. */
[33766]917 }
918 return hrc;
919}
920
921
922/**
[42189]923 * List machine groups.
924 *
925 * @returns See produceList.
[42748]926 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
[42189]927 */
[42748]928static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
[42189]929{
930 SafeArray<BSTR> groups;
[56118]931 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
[42189]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/**
[48600]942 * List video capture devices.
943 *
944 * @returns See produceList.
945 * @param pVirtualBox Reference to the IVirtualBox pointer.
946 */
[48607]947static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox)
[48600]948{
949 HRESULT rc;
950 ComPtr<IHost> host;
951 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
[48607]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)
[48600]956 {
[48607]957 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
[48600]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
[52200]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)));
[48600]982
[52200]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
[73716]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)));
[52200]1011
[73716]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
[48600]1031/**
[73716]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/**
[33759]1089 * The type of lists we can produce.
1090 */
1091enum enmListType
[17078]1092{
[33759]1093 kListNotSpecified = 1000,
1094 kListVMs,
1095 kListRunningVMs,
1096 kListOsTypes,
1097 kListHostDvds,
1098 kListHostFloppies,
[48538]1099 kListInternalNetworks,
[33759]1100 kListBridgedInterfaces,
[17945]1101#if defined(VBOX_WITH_NETFLT)
[33759]1102 kListHostOnlyInterfaces,
[17322]1103#endif
[33759]1104 kListHostCpuIDs,
1105 kListHostInfo,
1106 kListHddBackends,
1107 kListHdds,
1108 kListDvds,
1109 kListFloppies,
1110 kListUsbHost,
1111 kListUsbFilters,
1112 kListSystemProperties,
1113 kListDhcpServers,
[42189]1114 kListExtPacks,
[45156]1115 kListGroups,
[48600]1116 kListNatNetworks,
[52200]1117 kListVideoInputDevices,
[73716]1118 kListScreenShotFormats,
1119 kListCloudProviders,
1120 kListCloudProfiles,
[17078]1121};
1122
1123
[33759]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.
[42748]1130 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
[33759]1131 */
[65517]1132static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
[1]1133{
1134 HRESULT rc = S_OK;
[33759]1135 switch (enmCommand)
[17078]1136 {
[33759]1137 case kListNotSpecified:
1138 AssertFailed();
1139 return E_FAIL;
[17078]1140
[33759]1141 case kListVMs:
[1]1142 {
1143 /*
[17078]1144 * Get the list of all registered VMs
[1]1145 */
[33759]1146 com::SafeIfaceArray<IMachine> machines;
[42748]1147 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
[17078]1148 if (SUCCEEDED(rc))
[1]1149 {
[17078]1150 /*
[65517]1151 * Display it.
[17078]1152 */
[65517]1153 if (!fOptSorted)
[17078]1154 {
[65517]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);
[17078]1158 }
[65517]1159 else
1160 {
1161 /*
1162 * Sort the list by name before displaying it.
1163 */
[65518]1164 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
[65517]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 }
[1]1181 }
[33759]1182 break;
[1]1183 }
[17078]1184
[33759]1185 case kListRunningVMs:
[6526]1186 {
1187 /*
[17078]1188 * Get the list of all _running_ VMs
[6526]1189 */
[33759]1190 com::SafeIfaceArray<IMachine> machines;
[42748]1191 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
[40540]1192 com::SafeArray<MachineState_T> states;
[17078]1193 if (SUCCEEDED(rc))
[42748]1194 rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
[40540]1195 if (SUCCEEDED(rc))
[6526]1196 {
[17078]1197 /*
1198 * Iterate through the collection
1199 */
[28249]1200 for (size_t i = 0; i < machines.size(); ++i)
[6526]1201 {
[17737]1202 if (machines[i])
[6526]1203 {
[40540]1204 MachineState_T machineState = states[i];
1205 switch (machineState)
[6526]1206 {
[40540]1207 case MachineState_Running:
1208 case MachineState_Teleporting:
1209 case MachineState_LiveSnapshotting:
1210 case MachineState_Paused:
1211 case MachineState_TeleportingPausedVM:
[53266]1212 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
[40540]1213 break;
[63300]1214 default: break; /* Shut up MSC */
[6526]1215 }
1216 }
1217 }
1218 }
[33759]1219 break;
[6526]1220 }
[17078]1221
[33759]1222 case kListOsTypes:
[1]1223 {
[33759]1224 com::SafeIfaceArray<IGuestOSType> coll;
[42748]1225 rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
[17078]1226 if (SUCCEEDED(rc))
[1]1227 {
[17078]1228 /*
[17238]1229 * Iterate through the collection.
1230 */
[28249]1231 for (size_t i = 0; i < coll.size(); ++i)
[17078]1232 {
1233 ComPtr<IGuestOSType> guestOS;
1234 guestOS = coll[i];
1235 Bstr guestId;
1236 guestOS->COMGETTER(Id)(guestId.asOutParam());
[38735]1237 RTPrintf("ID: %ls\n", guestId.raw());
[17078]1238 Bstr guestDescription;
1239 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
[39248]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");
[17078]1251 }
[1]1252 }
[33759]1253 break;
[1]1254 }
[17078]1255
[33759]1256 case kListHostDvds:
[1]1257 {
[17078]1258 ComPtr<IHost> host;
[42748]1259 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
[33759]1260 com::SafeIfaceArray<IMedium> coll;
[17238]1261 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
1262 if (SUCCEEDED(rc))
[1]1263 {
[28249]1264 for (size_t i = 0; i < coll.size(); ++i)
[17078]1265 {
[23223]1266 ComPtr<IMedium> dvdDrive = coll[i];
1267 Bstr uuid;
1268 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
[31539]1269 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
[35801]1270 Bstr location;
1271 dvdDrive->COMGETTER(Location)(location.asOutParam());
[38735]1272 RTPrintf("Name: %ls\n\n", location.raw());
[17078]1273 }
[1]1274 }
[33759]1275 break;
[1]1276 }
[17078]1277
[33759]1278 case kListHostFloppies:
[1]1279 {
[17078]1280 ComPtr<IHost> host;
[42748]1281 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
[33759]1282 com::SafeIfaceArray<IMedium> coll;
[17255]1283 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
1284 if (SUCCEEDED(rc))
[1]1285 {
[17255]1286 for (size_t i = 0; i < coll.size(); ++i)
[17078]1287 {
[23223]1288 ComPtr<IMedium> floppyDrive = coll[i];
1289 Bstr uuid;
1290 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
[31539]1291 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
[35801]1292 Bstr location;
1293 floppyDrive->COMGETTER(Location)(location.asOutParam());
[38735]1294 RTPrintf("Name: %ls\n\n", location.raw());
[17078]1295 }
[1]1296 }
[33759]1297 break;
[1]1298 }
[17078]1299
[48538]1300 case kListInternalNetworks:
1301 rc = listInternalNetworks(pVirtualBox);
1302 break;
1303
[33759]1304 case kListBridgedInterfaces:
[17945]1305#if defined(VBOX_WITH_NETFLT)
[33759]1306 case kListHostOnlyInterfaces:
[17322]1307#endif
[42748]1308 rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
[33759]1309 break;
[10412]1310
[33759]1311 case kListHostInfo:
[42748]1312 rc = listHostInfo(pVirtualBox);
[33759]1313 break;
[17078]1314
[33759]1315 case kListHostCpuIDs:
[24404]1316 {
1317 ComPtr<IHost> Host;
[42748]1318 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
[24404]1319
1320 RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
1321 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
[24416]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;
[27537]1331 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
[24416]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++)
[24404]1336 {
[27537]1337 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
[24404]1338 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
1339 }
[24416]1340 }
[33759]1341 break;
[24404]1342 }
1343
[33759]1344 case kListHddBackends:
[42748]1345 rc = listHddBackends(pVirtualBox);
[33759]1346 break;
[17078]1347
[33759]1348 case kListHdds:
[1]1349 {
[23223]1350 com::SafeIfaceArray<IMedium> hdds;
[42748]1351 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
[44498]1352 rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
[33759]1353 break;
[1]1354 }
[17078]1355
[33759]1356 case kListDvds:
[1]1357 {
[23223]1358 com::SafeIfaceArray<IMedium> dvds;
[42748]1359 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
[44498]1360 rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
[33759]1361 break;
[1]1362 }
[17078]1363
[33759]1364 case kListFloppies:
[1]1365 {
[23223]1366 com::SafeIfaceArray<IMedium> floppies;
[42748]1367 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
[44498]1368 rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
[33759]1369 break;
[1]1370 }
1371
[33759]1372 case kListUsbHost:
[42748]1373 rc = listUsbHost(pVirtualBox);
[33759]1374 break;
[1]1375
[33759]1376 case kListUsbFilters:
[42748]1377 rc = listUsbFilters(pVirtualBox);
[33759]1378 break;
[1]1379
[33759]1380 case kListSystemProperties:
[42748]1381 rc = listSystemProperties(pVirtualBox);
[33759]1382 break;
[8373]1383
[33759]1384 case kListDhcpServers:
[75819]1385 rc = listDhcpServers(pVirtualBox);
[33759]1386 break;
1387
[33766]1388 case kListExtPacks:
[42748]1389 rc = listExtensionPacks(pVirtualBox);
[33766]1390 break;
1391
[42189]1392 case kListGroups:
[42748]1393 rc = listGroups(pVirtualBox);
[42189]1394 break;
1395
[45156]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);
[47483]1414 RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No");
[45156]1415 Bstr ipv6prefix;
[58763]1416 net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
[45156]1417 RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw());
1418 net->COMGETTER(NeedDhcpServer)(&fEnabled);
[47483]1419 RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No");
[45156]1420 net->COMGETTER(Enabled)(&fEnabled);
1421 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
[48538]1422
[48097]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()); \
[48538]1430 }
[48097]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
[45156]1447 RTPrintf("\n");
1448 }
1449 break;
1450 }
1451
[48607]1452 case kListVideoInputDevices:
1453 rc = listVideoInputDevices(pVirtualBox);
[48600]1454 break;
1455
[52200]1456 case kListScreenShotFormats:
1457 rc = listScreenShotFormats(pVirtualBox);
1458 break;
1459
[73716]1460 case kListCloudProviders:
1461 rc = listCloudProviders(pVirtualBox);
1462 break;
1463
1464 case kListCloudProfiles:
1465 rc = listCloudProfiles(pVirtualBox, fOptLong);
1466 break;
1467
[33759]1468 /* No default here, want gcc warnings. */
1469
1470 } /* end switch */
1471
1472 return rc;
[1]1473}
1474
[33759]1475/**
1476 * Handles the 'list' command.
1477 *
1478 * @returns Appropriate exit code.
1479 * @param a Handler argument.
1480 */
[56118]1481RTEXITCODE handleList(HandlerArg *a)
[33759]1482{
1483 bool fOptLong = false;
1484 bool fOptMultiple = false;
[65517]1485 bool fOptSorted = false;
[33759]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 */
[65517]1492 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
[33759]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 },
[48538]1498 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
[33759]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
[48538]1504 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1505 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
[33759]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 },
[33766]1516 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
[42189]1517 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
[48607]1518 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
[52200]1519 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
[73716]1520 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
1521 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
[33759]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
[65517]1537 case 's':
1538 fOptSorted = true;
1539 break;
1540
[33759]1541 case 'm':
1542 fOptMultiple = true;
1543 if (enmOptCommand == kListNotSpecified)
1544 break;
1545 ch = enmOptCommand;
[69046]1546 RT_FALL_THRU();
[33759]1547
1548 case kListVMs:
1549 case kListRunningVMs:
1550 case kListOsTypes:
1551 case kListHostDvds:
1552 case kListHostFloppies:
[48538]1553 case kListInternalNetworks:
[33759]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:
[33766]1568 case kListExtPacks:
[42189]1569 case kListGroups:
[45156]1570 case kListNatNetworks:
[48607]1571 case kListVideoInputDevices:
[52200]1572 case kListScreenShotFormats:
[73716]1573 case kListCloudProviders:
1574 case kListCloudProfiles:
[33759]1575 enmOptCommand = (enum enmListType)ch;
1576 if (fOptMultiple)
1577 {
[65517]1578 HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox);
[33759]1579 if (FAILED(hrc))
[56118]1580 return RTEXITCODE_FAILURE;
[33759]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 {
[65517]1599 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
[33759]1600 if (FAILED(hrc))
[56118]1601 return RTEXITCODE_FAILURE;
[33759]1602 }
1603
[56118]1604 return RTEXITCODE_SUCCESS;
[33759]1605}
1606
[14612]1607#endif /* !VBOX_ONLY_DOCS */
[17238]1608/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use