VirtualBox

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

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

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