VirtualBox

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

Last change on this file since 102037 was 101593, checked in by vboxsync, 19 months ago

doc/manual,Frontends/VBoxManage,Main/{Global,GuestOSType,VirtualBox.xidl}:
Revisit the OS guest OS changes which added a new 'variant' field to the
Global::sOSTypes[] table along with a new VBoxManage subcommand and
IVirtualBox methods for accessing the guest OS variant information
(r159137). After discussion with the documentation team the identifier
'variant' is being changed to the clearer 'subtype' which also doesn't
overlap with the 'variant' terminology used with medium management
(IMedium::variant(), the MediumVariant enum, etc.). bugref:5936
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 105.5 KB
Line 
1/* $Id: VBoxManageList.cpp 101593 2023-10-25 15:37:09Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'list' command.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include <VBox/com/com.h>
33#include <VBox/com/string.h>
34#include <VBox/com/Guid.h>
35#include <VBox/com/array.h>
36#include <VBox/com/ErrorInfo.h>
37#include <VBox/com/errorprint.h>
38
39#include <VBox/com/VirtualBox.h>
40
41#include <VBox/log.h>
42#include <iprt/stream.h>
43#include <iprt/string.h>
44#include <iprt/time.h>
45#include <iprt/getopt.h>
46#include <iprt/ctype.h>
47
48#include <vector>
49#include <algorithm>
50
51#include "VBoxManage.h"
52using namespace com;
53
54DECLARE_TRANSLATION_CONTEXT(List);
55
56#ifdef VBOX_WITH_HOSTNETIF_API
57static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
58{
59 switch (enmType)
60 {
61 case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
62 case HostNetworkInterfaceMediumType_PPP: return "PPP";
63 case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
64 case HostNetworkInterfaceMediumType_Unknown: return List::tr("Unknown");
65#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
66 case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
67#endif
68 }
69 return List::tr("unknown");
70}
71
72static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus)
73{
74 switch (enmStatus)
75 {
76 case HostNetworkInterfaceStatus_Up: return List::tr("Up");
77 case HostNetworkInterfaceStatus_Down: return List::tr("Down");
78 case HostNetworkInterfaceStatus_Unknown: return List::tr("Unknown");
79#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
80 case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
81#endif
82 }
83 return List::tr("unknown");
84}
85#endif /* VBOX_WITH_HOSTNETIF_API */
86
87static const char*getDeviceTypeText(DeviceType_T enmType)
88{
89 switch (enmType)
90 {
91 case DeviceType_HardDisk: return List::tr("HardDisk");
92 case DeviceType_DVD: return "DVD";
93 case DeviceType_Floppy: return List::tr("Floppy");
94 /* Make MSC happy */
95 case DeviceType_Null: return "Null";
96 case DeviceType_Network: return List::tr("Network");
97 case DeviceType_USB: return "USB";
98 case DeviceType_SharedFolder: return List::tr("SharedFolder");
99 case DeviceType_Graphics3D: return List::tr("Graphics3D");
100 case DeviceType_End: break; /* Shut up compiler warnings. */
101#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
102 case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
103#endif
104 }
105 return List::tr("Unknown");
106}
107
108
109/**
110 * List internal networks.
111 *
112 * @returns See produceList.
113 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
114 */
115static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox)
116{
117 HRESULT hrc;
118 com::SafeArray<BSTR> internalNetworks;
119 CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
120 for (size_t i = 0; i < internalNetworks.size(); ++i)
121 {
122 RTPrintf(List::tr("Name: %ls\n"), internalNetworks[i]);
123 }
124 return hrc;
125}
126
127
128/**
129 * List network interfaces information (bridged/host only).
130 *
131 * @returns See produceList.
132 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
133 * @param fIsBridged Selects between listing host interfaces (for
134 * use with bridging) or host only interfaces.
135 */
136static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox,
137 bool fIsBridged)
138{
139 HRESULT hrc;
140 ComPtr<IHost> host;
141 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
142 com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
143#if defined(VBOX_WITH_NETFLT)
144 if (fIsBridged)
145 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged,
146 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
147 else
148 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly,
149 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
150#else
151 RT_NOREF(fIsBridged);
152 CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
153#endif
154 for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
155 {
156 ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i];
157#ifndef VBOX_WITH_HOSTNETIF_API
158 Bstr interfaceName;
159 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
160 RTPrintf(List::tr("Name: %ls\n"), interfaceName.raw());
161 Guid interfaceGuid;
162 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
163 RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
164#else /* VBOX_WITH_HOSTNETIF_API */
165 Bstr interfaceName;
166 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
167 RTPrintf(List::tr("Name: %ls\n"), interfaceName.raw());
168 Bstr interfaceGuid;
169 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
170 RTPrintf("GUID: %ls\n", interfaceGuid.raw());
171 BOOL fDHCPEnabled = FALSE;
172 networkInterface->COMGETTER(DHCPEnabled)(&fDHCPEnabled);
173 RTPrintf("DHCP: %s\n", fDHCPEnabled ? List::tr("Enabled") : List::tr("Disabled"));
174
175 Bstr IPAddress;
176 networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
177 RTPrintf(List::tr("IPAddress: %ls\n"), IPAddress.raw());
178 Bstr NetworkMask;
179 networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
180 RTPrintf(List::tr("NetworkMask: %ls\n"), NetworkMask.raw());
181 Bstr IPV6Address;
182 networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
183 RTPrintf(List::tr("IPV6Address: %ls\n"), IPV6Address.raw());
184 ULONG IPV6NetworkMaskPrefixLength;
185 networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
186 RTPrintf(List::tr("IPV6NetworkMaskPrefixLength: %d\n"), IPV6NetworkMaskPrefixLength);
187 Bstr HardwareAddress;
188 networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
189 RTPrintf(List::tr("HardwareAddress: %ls\n"), HardwareAddress.raw());
190 HostNetworkInterfaceMediumType_T Type;
191 networkInterface->COMGETTER(MediumType)(&Type);
192 RTPrintf(List::tr("MediumType: %s\n"), getHostIfMediumTypeText(Type));
193 BOOL fWireless = FALSE;
194 networkInterface->COMGETTER(Wireless)(&fWireless);
195 RTPrintf(List::tr("Wireless: %s\n"), fWireless ? List::tr("Yes") : List::tr("No"));
196 HostNetworkInterfaceStatus_T Status;
197 networkInterface->COMGETTER(Status)(&Status);
198 RTPrintf(List::tr("Status: %s\n"), getHostIfStatusText(Status));
199 Bstr netName;
200 networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
201 RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
202#endif
203 }
204 return hrc;
205}
206
207
208#ifdef VBOX_WITH_VMNET
209/**
210 * List configured host-only networks.
211 *
212 * @returns See produceList.
213 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
214 * @param Reserved Placeholder!
215 */
216static HRESULT listHostOnlyNetworks(const ComPtr<IVirtualBox> pVirtualBox)
217{
218 HRESULT hrc;
219 com::SafeIfaceArray<IHostOnlyNetwork> hostOnlyNetworks;
220 CHECK_ERROR(pVirtualBox, COMGETTER(HostOnlyNetworks)(ComSafeArrayAsOutParam(hostOnlyNetworks)));
221 for (size_t i = 0; i < hostOnlyNetworks.size(); ++i)
222 {
223 ComPtr<IHostOnlyNetwork> hostOnlyNetwork = hostOnlyNetworks[i];
224 Bstr bstrNetworkName;
225 CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(NetworkName)(bstrNetworkName.asOutParam()));
226 RTPrintf(List::tr("Name: %ls\n"), bstrNetworkName.raw());
227
228 Bstr bstr;
229 CHECK_ERROR(hostOnlyNetwork, COMGETTER(Id)(bstr.asOutParam()));
230 RTPrintf("GUID: %ls\n\n", bstr.raw());
231
232 BOOL fEnabled = FALSE;
233 CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(Enabled)(&fEnabled));
234 RTPrintf(List::tr("State: %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
235
236 CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(NetworkMask)(bstr.asOutParam()));
237 RTPrintf(List::tr("NetworkMask: %ls\n"), bstr.raw());
238
239 CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(LowerIP)(bstr.asOutParam()));
240 RTPrintf(List::tr("LowerIP: %ls\n"), bstr.raw());
241
242 CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(UpperIP)(bstr.asOutParam()));
243 RTPrintf(List::tr("UpperIP: %ls\n"), bstr.raw());
244
245 // CHECK_ERROR2I(hostOnlyNetwork, COMGETTER(Id)(bstr.asOutParam());
246 // RTPrintf("NetworkId: %ls\n", bstr.raw());
247
248 RTPrintf(List::tr("VBoxNetworkName: hostonly-%ls\n\n"), bstrNetworkName.raw());
249 }
250 return hrc;
251}
252#endif /* VBOX_WITH_VMNET */
253
254
255#ifdef VBOX_WITH_CLOUD_NET
256/**
257 * List configured cloud network attachments.
258 *
259 * @returns See produceList.
260 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
261 * @param Reserved Placeholder!
262 */
263static HRESULT listCloudNetworks(const ComPtr<IVirtualBox> pVirtualBox)
264{
265 com::SafeIfaceArray<ICloudNetwork> cloudNetworks;
266 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(CloudNetworks)(ComSafeArrayAsOutParam(cloudNetworks)), hrcCheck);
267 for (size_t i = 0; i < cloudNetworks.size(); ++i)
268 {
269 ComPtr<ICloudNetwork> cloudNetwork = cloudNetworks[i];
270 Bstr networkName;
271 cloudNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
272 RTPrintf(List::tr("Name: %ls\n"), networkName.raw());
273 // Guid interfaceGuid;
274 // cloudNetwork->COMGETTER(Id)(interfaceGuid.asOutParam());
275 // RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
276 BOOL fEnabled = FALSE;
277 cloudNetwork->COMGETTER(Enabled)(&fEnabled);
278 RTPrintf(List::tr("State: %s\n"), fEnabled ? List::tr("Enabled") : List::tr("Disabled"));
279
280 Bstr Provider;
281 cloudNetwork->COMGETTER(Provider)(Provider.asOutParam());
282 RTPrintf(List::tr("CloudProvider: %ls\n"), Provider.raw());
283 Bstr Profile;
284 cloudNetwork->COMGETTER(Profile)(Profile.asOutParam());
285 RTPrintf(List::tr("CloudProfile: %ls\n"), Profile.raw());
286 Bstr NetworkId;
287 cloudNetwork->COMGETTER(NetworkId)(NetworkId.asOutParam());
288 RTPrintf(List::tr("CloudNetworkId: %ls\n"), NetworkId.raw());
289 Bstr netName = BstrFmt("cloud-%ls", networkName.raw());
290 RTPrintf(List::tr("VBoxNetworkName: %ls\n\n"), netName.raw());
291 }
292 return S_OK;
293}
294#endif /* VBOX_WITH_CLOUD_NET */
295
296
297/**
298 * List host information.
299 *
300 * @returns See produceList.
301 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
302 */
303static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox)
304{
305 static struct
306 {
307 ProcessorFeature_T feature;
308 const char *pszName;
309 } features[]
310 =
311 {
312 { ProcessorFeature_HWVirtEx, List::tr("HW virtualization") },
313 { ProcessorFeature_PAE, "PAE" },
314 { ProcessorFeature_LongMode, List::tr("long mode") },
315 { ProcessorFeature_NestedPaging, List::tr("nested paging") },
316 { ProcessorFeature_UnrestrictedGuest, List::tr("unrestricted guest") },
317 { ProcessorFeature_NestedHWVirt, List::tr("nested HW virtualization") },
318 { ProcessorFeature_VirtVmsaveVmload, List::tr("virt. vmsave/vmload") },
319 };
320 HRESULT hrc;
321 ComPtr<IHost> Host;
322 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
323
324 RTPrintf(List::tr("Host Information:\n\n"));
325
326 LONG64 u64UtcTime = 0;
327 CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
328 RTTIMESPEC timeSpec;
329 char szTime[32];
330 RTPrintf(List::tr("Host time: %s\n"), RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
331
332 ULONG processorOnlineCount = 0;
333 CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
334 RTPrintf(List::tr("Processor online count: %lu\n"), processorOnlineCount);
335 ULONG processorCount = 0;
336 CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
337 RTPrintf(List::tr("Processor count: %lu\n"), processorCount);
338 ULONG processorOnlineCoreCount = 0;
339 CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
340 RTPrintf(List::tr("Processor online core count: %lu\n"), processorOnlineCoreCount);
341 ULONG processorCoreCount = 0;
342 CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
343 RTPrintf(List::tr("Processor core count: %lu\n"), processorCoreCount);
344 for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
345 {
346 BOOL supported;
347 CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
348 RTPrintf(List::tr("Processor supports %s: %s\n"), features[i].pszName, supported ? List::tr("yes") : List::tr("no"));
349 }
350 for (ULONG i = 0; i < processorCount; i++)
351 {
352 ULONG processorSpeed = 0;
353 CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
354 if (processorSpeed)
355 RTPrintf(List::tr("Processor#%u speed: %lu MHz\n"), i, processorSpeed);
356 else
357 RTPrintf(List::tr("Processor#%u speed: unknown\n"), i);
358 Bstr processorDescription;
359 CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
360 RTPrintf(List::tr("Processor#%u description: %ls\n"), i, processorDescription.raw());
361 }
362
363 ULONG memorySize = 0;
364 CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
365 RTPrintf(List::tr("Memory size: %lu MByte\n", "", memorySize), memorySize);
366
367 ULONG memoryAvailable = 0;
368 CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
369 RTPrintf(List::tr("Memory available: %lu MByte\n", "", memoryAvailable), memoryAvailable);
370
371 Bstr operatingSystem;
372 CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
373 RTPrintf(List::tr("Operating system: %ls\n"), operatingSystem.raw());
374
375 Bstr oSVersion;
376 CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
377 RTPrintf(List::tr("Operating system version: %ls\n"), oSVersion.raw());
378 return hrc;
379}
380
381
382/**
383 * List media information.
384 *
385 * @returns See produceList.
386 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
387 * @param aMedia Medium objects to list information for.
388 * @param pszParentUUIDStr String with the parent UUID string (or "base").
389 * @param fOptLong Long (@c true) or short list format.
390 */
391static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
392 const com::SafeIfaceArray<IMedium> &aMedia,
393 const char *pszParentUUIDStr,
394 bool fOptLong)
395{
396 HRESULT hrc = S_OK;
397 for (size_t i = 0; i < aMedia.size(); ++i)
398 {
399 ComPtr<IMedium> pMedium = aMedia[i];
400
401 hrc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
402
403 RTPrintf("\n");
404
405 com::SafeIfaceArray<IMedium> children;
406 CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
407 if (children.size() > 0)
408 {
409 Bstr uuid;
410 pMedium->COMGETTER(Id)(uuid.asOutParam());
411
412 // depth first listing of child media
413 hrc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
414 }
415 }
416
417 return hrc;
418}
419
420
421/**
422 * List virtual image backends.
423 *
424 * @returns See produceList.
425 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
426 */
427static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox)
428{
429 HRESULT hrc;
430 ComPtr<ISystemProperties> systemProperties;
431 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
432 com::SafeIfaceArray<IMediumFormat> mediumFormats;
433 CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
434
435 RTPrintf(List::tr("Supported hard disk backends:\n\n"));
436 for (size_t i = 0; i < mediumFormats.size(); ++i)
437 {
438 /* General information */
439 Bstr id;
440 CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam()));
441
442 Bstr description;
443 CHECK_ERROR(mediumFormats[i],
444 COMGETTER(Name)(description.asOutParam()));
445
446 ULONG caps = 0;
447 com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
448 CHECK_ERROR(mediumFormats[i],
449 COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)));
450 for (ULONG j = 0; j < mediumFormatCap.size(); j++)
451 caps |= mediumFormatCap[j];
452
453
454 RTPrintf(List::tr("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='"),
455 i, id.raw(), description.raw(), caps);
456
457 /* File extensions */
458 com::SafeArray<BSTR> fileExtensions;
459 com::SafeArray<DeviceType_T> deviceTypes;
460 CHECK_ERROR(mediumFormats[i],
461 DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
462 for (size_t j = 0; j < fileExtensions.size(); ++j)
463 {
464 RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
465 if (j != fileExtensions.size()-1)
466 RTPrintf(",");
467 }
468 RTPrintf("'");
469
470 /* Configuration keys */
471 com::SafeArray<BSTR> propertyNames;
472 com::SafeArray<BSTR> propertyDescriptions;
473 com::SafeArray<DataType_T> propertyTypes;
474 com::SafeArray<ULONG> propertyFlags;
475 com::SafeArray<BSTR> propertyDefaults;
476 CHECK_ERROR(mediumFormats[i],
477 DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
478 ComSafeArrayAsOutParam(propertyDescriptions),
479 ComSafeArrayAsOutParam(propertyTypes),
480 ComSafeArrayAsOutParam(propertyFlags),
481 ComSafeArrayAsOutParam(propertyDefaults)));
482
483 RTPrintf(List::tr(" properties=("));
484 if (propertyNames.size() > 0)
485 {
486 for (size_t j = 0; j < propertyNames.size(); ++j)
487 {
488 RTPrintf(List::tr("\n name='%ls' desc='%ls' type="),
489 Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
490 switch (propertyTypes[j])
491 {
492 case DataType_Int32: RTPrintf(List::tr("int")); break;
493 case DataType_Int8: RTPrintf(List::tr("byte")); break;
494 case DataType_String: RTPrintf(List::tr("string")); break;
495#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
496 case DataType_32BitHack: break; /* Shut up compiler warnings. */
497#endif
498 }
499 RTPrintf(List::tr(" flags=%#04x"), propertyFlags[j]);
500 RTPrintf(List::tr(" default='%ls'"), Bstr(propertyDefaults[j]).raw());
501 if (j != propertyNames.size()-1)
502 RTPrintf(", ");
503 }
504 }
505 RTPrintf(")\n");
506 }
507 return hrc;
508}
509
510
511/**
512 * List USB devices attached to the host.
513 *
514 * @returns See produceList.
515 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
516 */
517static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox)
518{
519 HRESULT hrc;
520 ComPtr<IHost> Host;
521 CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
522
523 SafeIfaceArray<IHostUSBDevice> CollPtr;
524 CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
525
526 RTPrintf(List::tr("Host USB Devices:\n\n"));
527
528 if (CollPtr.size() == 0)
529 {
530 RTPrintf(List::tr("<none>\n\n"));
531 }
532 else
533 {
534 for (size_t i = 0; i < CollPtr.size(); ++i)
535 {
536 ComPtr<IHostUSBDevice> dev = CollPtr[i];
537
538 /* Query info. */
539 Bstr id;
540 CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1);
541 USHORT usVendorId;
542 CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1);
543 USHORT usProductId;
544 CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1);
545 USHORT bcdRevision;
546 CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1);
547 USHORT usPort;
548 CHECK_ERROR_RET(dev, COMGETTER(Port)(&usPort), 1);
549 USHORT usVersion;
550 CHECK_ERROR_RET(dev, COMGETTER(Version)(&usVersion), 1);
551 USBConnectionSpeed_T enmSpeed;
552 CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
553
554 RTPrintf(List::tr(
555 "UUID: %s\n"
556 "VendorId: %#06x (%04X)\n"
557 "ProductId: %#06x (%04X)\n"
558 "Revision: %u.%u (%02u%02u)\n"
559 "Port: %u\n"),
560 Utf8Str(id).c_str(),
561 usVendorId, usVendorId, usProductId, usProductId,
562 bcdRevision >> 8, bcdRevision & 0xff,
563 bcdRevision >> 8, bcdRevision & 0xff,
564 usPort);
565
566 const char *pszSpeed = "?";
567 switch (enmSpeed)
568 {
569 case USBConnectionSpeed_Low:
570 pszSpeed = List::tr("Low");
571 break;
572 case USBConnectionSpeed_Full:
573 pszSpeed = List::tr("Full");
574 break;
575 case USBConnectionSpeed_High:
576 pszSpeed = List::tr("High");
577 break;
578 case USBConnectionSpeed_Super:
579 pszSpeed = List::tr("Super");
580 break;
581 case USBConnectionSpeed_SuperPlus:
582 pszSpeed = List::tr("SuperPlus");
583 break;
584 default:
585 ASSERT(false);
586 break;
587 }
588
589 RTPrintf(List::tr("USB version/speed: %u/%s\n"), usVersion, pszSpeed);
590
591 /* optional stuff. */
592 SafeArray<BSTR> CollDevInfo;
593 Bstr bstr;
594 CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1);
595 if (CollDevInfo.size() >= 1)
596 bstr = Bstr(CollDevInfo[0]);
597 if (!bstr.isEmpty())
598 RTPrintf(List::tr("Manufacturer: %ls\n"), bstr.raw());
599 if (CollDevInfo.size() >= 2)
600 bstr = Bstr(CollDevInfo[1]);
601 if (!bstr.isEmpty())
602 RTPrintf(List::tr("Product: %ls\n"), bstr.raw());
603 CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
604 if (!bstr.isEmpty())
605 RTPrintf(List::tr("SerialNumber: %ls\n"), bstr.raw());
606 CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
607 if (!bstr.isEmpty())
608 RTPrintf(List::tr("Address: %ls\n"), bstr.raw());
609 CHECK_ERROR_RET(dev, COMGETTER(PortPath)(bstr.asOutParam()), 1);
610 if (!bstr.isEmpty())
611 RTPrintf(List::tr("Port path: %ls\n"), bstr.raw());
612
613 /* current state */
614 USBDeviceState_T state;
615 CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1);
616 const char *pszState = "?";
617 switch (state)
618 {
619 case USBDeviceState_NotSupported:
620 pszState = List::tr("Not supported");
621 break;
622 case USBDeviceState_Unavailable:
623 pszState = List::tr("Unavailable");
624 break;
625 case USBDeviceState_Busy:
626 pszState = List::tr("Busy");
627 break;
628 case USBDeviceState_Available:
629 pszState = List::tr("Available");
630 break;
631 case USBDeviceState_Held:
632 pszState = List::tr("Held");
633 break;
634 case USBDeviceState_Captured:
635 pszState = List::tr("Captured");
636 break;
637 default:
638 ASSERT(false);
639 break;
640 }
641 RTPrintf(List::tr("Current State: %s\n\n"), pszState);
642 }
643 }
644 return hrc;
645}
646
647
648/**
649 * List USB filters.
650 *
651 * @returns See produceList.
652 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
653 */
654static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox)
655{
656 HRESULT hrc;
657
658 RTPrintf(List::tr("Global USB Device Filters:\n\n"));
659
660 ComPtr<IHost> host;
661 CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(host.asOutParam()), 1);
662
663 SafeIfaceArray<IHostUSBDeviceFilter> coll;
664 CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1);
665
666 if (coll.size() == 0)
667 {
668 RTPrintf(List::tr("<none>\n\n"));
669 }
670 else
671 {
672 for (size_t index = 0; index < coll.size(); ++index)
673 {
674 ComPtr<IHostUSBDeviceFilter> flt = coll[index];
675
676 /* Query info. */
677
678 RTPrintf(List::tr("Index: %zu\n"), index);
679
680 BOOL active = FALSE;
681 CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
682 RTPrintf(List::tr("Active: %s\n"), active ? List::tr("yes") : List::tr("no"));
683
684 USBDeviceFilterAction_T action;
685 CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
686 const char *pszAction = List::tr("<invalid>");
687 switch (action)
688 {
689 case USBDeviceFilterAction_Ignore:
690 pszAction = List::tr("Ignore");
691 break;
692 case USBDeviceFilterAction_Hold:
693 pszAction = List::tr("Hold");
694 break;
695 default:
696 break;
697 }
698 RTPrintf(List::tr("Action: %s\n"), pszAction);
699
700 Bstr bstr;
701 CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
702 RTPrintf(List::tr("Name: %ls\n"), bstr.raw());
703 CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
704 RTPrintf(List::tr("VendorId: %ls\n"), bstr.raw());
705 CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
706 RTPrintf(List::tr("ProductId: %ls\n"), bstr.raw());
707 CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
708 RTPrintf(List::tr("Revision: %ls\n"), bstr.raw());
709 CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
710 RTPrintf(List::tr("Manufacturer: %ls\n"), bstr.raw());
711 CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
712 RTPrintf(List::tr("Product: %ls\n"), bstr.raw());
713 CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
714 RTPrintf(List::tr("Serial Number: %ls\n"), bstr.raw());
715 CHECK_ERROR_RET(flt, COMGETTER(Port)(bstr.asOutParam()), 1);
716 RTPrintf(List::tr("Port: %ls\n\n"), bstr.raw());
717 }
718 }
719 return hrc;
720}
721
722/**
723 * Returns the chipset type as a string.
724 *
725 * @return Chipset type as a string.
726 * @param enmType Chipset type to convert.
727 */
728static const char *chipsetTypeToStr(ChipsetType_T enmType)
729{
730 switch (enmType)
731 {
732 case ChipsetType_PIIX3: return "PIIX3";
733 case ChipsetType_ICH9: return "ICH9";
734 case ChipsetType_ARMv8Virtual: return "ARMv8Virtual";
735 case ChipsetType_Null:
736 default:
737 break;
738 }
739
740 return "<Unknown>";
741}
742
743/**
744 * Returns a platform architecture as a string.
745 *
746 * @return Platform architecture as a string.
747 * @param enmArch Platform architecture to convert.
748 */
749static const char *platformArchitectureToStr(PlatformArchitecture_T enmArch)
750{
751 switch (enmArch)
752 {
753 case PlatformArchitecture_x86: return "x86";
754 case PlatformArchitecture_ARM: return "ARMv8";
755 default:
756 break;
757 }
758
759 return "<Unknown>";
760}
761
762/** @todo r=andy Make use of SHOW_ULONG_PROP and friends like in VBoxManageInfo to have a more uniform / prettier output.
763 * Use nesting (as padding / tabs). */
764
765/**
766 * List chipset properties.
767 *
768 * @returns See produceList.
769 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
770 */
771static HRESULT listPlatformChipsetProperties(const ComPtr<IPlatformProperties> &pPlatformProperties, ChipsetType_T enmChipsetType)
772{
773 const char *pszChipset = chipsetTypeToStr(enmChipsetType);
774 AssertPtrReturn(pszChipset, E_INVALIDARG);
775
776 /* Note: Keep the chipset name within the description -- makes it easier to grep for specific chipsts manually. */
777 ULONG ulValue;
778 pPlatformProperties->GetMaxNetworkAdapters(enmChipsetType, &ulValue);
779 RTPrintf(List::tr("Maximum %s Network Adapter count: %u\n"), pszChipset, ulValue);
780 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_IDE, &ulValue);
781 RTPrintf(List::tr("Maximum %s IDE Controllers: %u\n"), pszChipset, ulValue);
782 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SATA, &ulValue);
783 RTPrintf(List::tr("Maximum %s SATA Controllers: %u\n"), pszChipset, ulValue);
784 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SCSI, &ulValue);
785 RTPrintf(List::tr("Maximum %s SCSI Controllers: %u\n"), pszChipset, ulValue);
786 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_SAS, &ulValue);
787 RTPrintf(List::tr("Maximum %s SAS Controllers: %u\n"), pszChipset, ulValue);
788 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_PCIe, &ulValue);
789 RTPrintf(List::tr("Maximum %s NVMe Controllers: %u\n"), pszChipset, ulValue);
790 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_VirtioSCSI, &ulValue);
791 RTPrintf(List::tr("Maximum %s virtio-scsi Controllers: %u\n"), pszChipset, ulValue);
792 pPlatformProperties->GetMaxInstancesOfStorageBus(enmChipsetType, StorageBus_Floppy, &ulValue);
793 RTPrintf(List::tr("Maximum %s Floppy Controllers:%u\n"), pszChipset, ulValue);
794
795 return S_OK;
796}
797
798/**
799 * Lists guest OS types.
800 *
801 * @returns HRESULT
802 * @param aGuestOSTypes Reference to guest OS types to list.
803 */
804static HRESULT listGuestOSTypes(const com::SafeIfaceArray<IGuestOSType> &aGuestOSTypes)
805{
806 /*
807 * Iterate through the collection.
808 */
809 for (size_t i = 0; i < aGuestOSTypes.size(); ++i)
810 {
811 ComPtr<IGuestOSType> guestOS;
812 guestOS = aGuestOSTypes[i];
813 Bstr guestId;
814 guestOS->COMGETTER(Id)(guestId.asOutParam());
815 RTPrintf("ID: %ls\n", guestId.raw());
816 Bstr guestDescription;
817 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
818 RTPrintf(List::tr("Description: %ls\n"), guestDescription.raw());
819 Bstr familyId;
820 guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
821 RTPrintf(List::tr("Family ID: %ls\n"), familyId.raw());
822 Bstr familyDescription;
823 guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
824 RTPrintf(List::tr("Family Desc: %ls\n"), familyDescription.raw());
825 Bstr guestOSSubtype;
826 guestOS->COMGETTER(Subtype)(guestOSSubtype.asOutParam());
827 if (guestOSSubtype.isNotEmpty())
828 RTPrintf(List::tr("OS Subtype: %ls\n"), guestOSSubtype.raw());
829 BOOL is64Bit;
830 guestOS->COMGETTER(Is64Bit)(&is64Bit);
831 RTPrintf(List::tr("64 bit: %RTbool\n"), is64Bit);
832 RTPrintf("\n");
833 }
834
835 return S_OK;
836}
837
838static HRESULT listPlatformProperties(const ComPtr<IPlatformProperties> &platformProperties)
839{
840 ULONG ulValue;
841 platformProperties->COMGETTER(SerialPortCount)(&ulValue);
842 RTPrintf(List::tr("Maximum Serial Port count: %u\n"), ulValue);
843 platformProperties->COMGETTER(ParallelPortCount)(&ulValue);
844 RTPrintf(List::tr("Maximum Parallel Port count: %u\n"), ulValue);
845 platformProperties->COMGETTER(MaxBootPosition)(&ulValue);
846 RTPrintf(List::tr("Maximum Boot Position: %u\n"), ulValue);
847 platformProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
848 RTPrintf(List::tr("Maximum Floppy Port count: %u\n"), ulValue);
849 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
850 RTPrintf(List::tr("Maximum Floppy Devices per Port: %u\n"), ulValue);
851 platformProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
852 RTPrintf(List::tr("Maximum virtio-scsi Port count: %u\n"), ulValue);
853 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
854 RTPrintf(List::tr("Maximum virtio-scsi Devices per Port: %u\n"), ulValue);
855 platformProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
856 RTPrintf(List::tr("Maximum IDE Port count: %u\n"), ulValue);
857 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
858 RTPrintf(List::tr("Maximum IDE Devices per port: %u\n"), ulValue);
859 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
860 RTPrintf(List::tr("Maximum SATA Port count: %u\n"), ulValue);
861 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
862 RTPrintf(List::tr("Maximum SATA Device per port: %u\n"), ulValue);
863 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
864 RTPrintf(List::tr("Maximum SCSI Port count: %u\n"), ulValue);
865 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
866 RTPrintf(List::tr("Maximum SCSI Devices per port: %u\n"), ulValue);
867 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
868 RTPrintf(List::tr("Maximum SAS Port count: %u\n"), ulValue);
869 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
870 RTPrintf(List::tr("Maximum SAS Devices per Port: %u\n"), ulValue);
871 platformProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
872 RTPrintf(List::tr("Maximum NVMe Port count: %u\n"), ulValue);
873 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
874 RTPrintf(List::tr("Maximum NVMe Devices per Port: %u\n"), ulValue);
875
876 SafeArray <ChipsetType_T> saChipset;
877 platformProperties->COMGETTER(SupportedChipsetTypes(ComSafeArrayAsOutParam(saChipset)));
878
879 RTPrintf(List::tr("Supported chipsets: "));
880 for (size_t i = 0; i < saChipset.size(); i++)
881 {
882 if (i > 0)
883 RTPrintf(", ");
884 RTPrintf("%s", chipsetTypeToStr(saChipset[i]));
885 }
886 RTPrintf("\n");
887
888 for (size_t i = 0; i < saChipset.size(); i++)
889 {
890 if (i > 0)
891 RTPrintf("\n");
892 RTPrintf(List::tr("%s chipset properties:\n"), chipsetTypeToStr(saChipset[i]));
893 listPlatformChipsetProperties(platformProperties, saChipset[i]);
894 }
895
896 RTPrintf("\n");
897
898 RTPrintf(List::tr("Supported guest OS types:\n\n"));
899
900 com::SafeIfaceArray<IGuestOSType> coll;
901 platformProperties->COMGETTER(SupportedGuestOSTypes(ComSafeArrayAsOutParam(coll)));
902 listGuestOSTypes(coll);
903
904 return S_OK;
905}
906
907/**
908 * List system properties.
909 *
910 * @returns See produceList.
911 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
912 */
913static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox)
914{
915 ComPtr<ISystemProperties> systemProperties;
916 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
917
918 ComPtr<IPlatformProperties> hostPlatformProperties;
919 CHECK_ERROR2I_RET(systemProperties, COMGETTER(Platform)(hostPlatformProperties.asOutParam()), hrcCheck);
920
921 Bstr str;
922 ULONG ulValue;
923 LONG64 i64Value;
924 BOOL fValue;
925 const char *psz;
926
927 pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
928 RTPrintf(List::tr("API version: %ls\n"), str.raw());
929
930 systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
931 RTPrintf(List::tr("Minimum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
932 systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
933 RTPrintf(List::tr("Maximum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
934 systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
935 RTPrintf(List::tr("Minimum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
936 systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
937 RTPrintf(List::tr("Maximum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
938 systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
939 RTPrintf(List::tr("Maximum guest monitor count: %u\n"), ulValue);
940 systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
941 RTPrintf(List::tr("Minimum guest CPU count: %u\n"), ulValue);
942 systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
943 RTPrintf(List::tr("Maximum guest CPU count: %u\n"), ulValue);
944 systemProperties->COMGETTER(InfoVDSize)(&i64Value);
945 RTPrintf(List::tr("Virtual disk limit (info): %lld Bytes\n", "" , i64Value), i64Value);
946
947#if 0
948 systemProperties->GetFreeDiskSpaceWarning(&i64Value);
949 RTPrintf(List::tr("Free disk space warning at: %u Bytes\n", "", i64Value), i64Value);
950 systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
951 RTPrintf(List::tr("Free disk space warning at: %u %%\n"), ulValue);
952 systemProperties->GetFreeDiskSpaceError(&i64Value);
953 RTPrintf(List::tr("Free disk space error at: %u Bytes\n", "", i64Value), i64Value);
954 systemProperties->GetFreeDiskSpacePercentError(&ulValue);
955 RTPrintf(List::tr("Free disk space error at: %u %%\n"), ulValue);
956#endif
957 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
958 RTPrintf(List::tr("Default machine folder: %ls\n"), str.raw());
959 hostPlatformProperties->COMGETTER(RawModeSupported)(&fValue);
960 RTPrintf(List::tr("Raw-mode Supported: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
961 hostPlatformProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
962 RTPrintf(List::tr("Exclusive HW virtualization use: %s\n"), fValue ? List::tr("on") : List::tr("off"));
963 systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
964 RTPrintf(List::tr("Default hard disk format: %ls\n"), str.raw());
965 systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
966 RTPrintf(List::tr("VRDE auth library: %ls\n"), str.raw());
967 systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
968 RTPrintf(List::tr("Webservice auth. library: %ls\n"), str.raw());
969 systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
970 RTPrintf(List::tr("Remote desktop ExtPack: %ls\n"), str.raw());
971 systemProperties->COMGETTER(DefaultCryptoExtPack)(str.asOutParam());
972 RTPrintf(List::tr("VM encryption ExtPack: %ls\n"), str.raw());
973 systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
974 RTPrintf(List::tr("Log history count: %u\n"), ulValue);
975 systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
976 RTPrintf(List::tr("Default frontend: %ls\n"), str.raw());
977 AudioDriverType_T enmAudio;
978 systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
979 switch (enmAudio)
980 {
981 case AudioDriverType_Default: psz = List::tr("Default"); break;
982 case AudioDriverType_Null: psz = List::tr("Null"); break;
983 case AudioDriverType_OSS: psz = "OSS"; break;
984 case AudioDriverType_ALSA: psz = "ALSA"; break;
985 case AudioDriverType_Pulse: psz = "PulseAudio"; break;
986 case AudioDriverType_WinMM: psz = "WinMM"; break;
987 case AudioDriverType_DirectSound: psz = "DirectSound"; break;
988 case AudioDriverType_WAS: psz = "Windows Audio Session"; break;
989 case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
990 case AudioDriverType_SolAudio: psz = "SolAudio"; break;
991 case AudioDriverType_MMPM: psz = "MMPM"; break;
992 default: psz = List::tr("Unknown");
993 }
994 RTPrintf(List::tr("Default audio driver: %s\n"), psz);
995 systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
996 RTPrintf(List::tr("Autostart database path: %ls\n"), str.raw());
997 systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
998 RTPrintf(List::tr("Default Guest Additions ISO: %ls\n"), str.raw());
999 systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
1000 RTPrintf(List::tr("Logging Level: %ls\n"), str.raw());
1001 ProxyMode_T enmProxyMode = (ProxyMode_T)42;
1002 systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
1003 psz = List::tr("Unknown");
1004 switch (enmProxyMode)
1005 {
1006 case ProxyMode_System: psz = List::tr("System"); break;
1007 case ProxyMode_NoProxy: psz = List::tr("NoProxy"); break;
1008 case ProxyMode_Manual: psz = List::tr("Manual"); break;
1009#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1010 case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */
1011#endif
1012 }
1013 RTPrintf(List::tr("Proxy Mode: %s\n"), psz);
1014 systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
1015 RTPrintf(List::tr("Proxy URL: %ls\n"), str.raw());
1016#ifdef VBOX_WITH_MAIN_NLS
1017 systemProperties->COMGETTER(LanguageId)(str.asOutParam());
1018 RTPrintf(List::tr("User language: %ls\n"), str.raw());
1019#endif
1020
1021 RTPrintf("Host platform properties:\n");
1022 listPlatformProperties(hostPlatformProperties);
1023
1024 /* Separate host system / platform properties stuff from guest platform properties a bit. */
1025 RTPrintf("\n");
1026
1027 SafeArray <PlatformArchitecture_T> saPlatformArch;
1028 systemProperties->COMGETTER(SupportedPlatformArchitectures(ComSafeArrayAsOutParam(saPlatformArch)));
1029 RTPrintf("Supported platform architectures: ");
1030 for (size_t i = 0; i < saPlatformArch.size(); ++i)
1031 {
1032 if (i > 0)
1033 RTPrintf(",");
1034 RTPrintf(platformArchitectureToStr(saPlatformArch[i]));
1035 }
1036 RTPrintf("\n\n");
1037
1038 for (size_t i = 0; i < saPlatformArch.size(); ++i)
1039 {
1040 if (i > 0)
1041 RTPrintf("\n");
1042 ComPtr<IPlatformProperties> platformProperties;
1043 pVirtualBox->GetPlatformProperties(saPlatformArch[i], platformProperties.asOutParam());
1044 RTPrintf(List::tr("%s platform properties:\n"), platformArchitectureToStr(saPlatformArch[i]));
1045 listPlatformProperties(platformProperties);
1046 }
1047
1048 return S_OK;
1049}
1050
1051#ifdef VBOX_WITH_UPDATE_AGENT
1052static HRESULT listUpdateAgentConfig(ComPtr<IUpdateAgent> ptrUpdateAgent)
1053{
1054 BOOL fValue;
1055 ptrUpdateAgent->COMGETTER(Enabled)(&fValue);
1056 RTPrintf(List::tr("Enabled: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
1057 ULONG ulValue;
1058 ptrUpdateAgent->COMGETTER(CheckCount)(&ulValue);
1059 RTPrintf(List::tr("Check count: %u\n"), ulValue);
1060 ptrUpdateAgent->COMGETTER(CheckFrequency)(&ulValue);
1061 if (ulValue == 0)
1062 RTPrintf(List::tr("Check frequency: never\n"));
1063 else if (ulValue == 1)
1064 RTPrintf(List::tr("Check frequency: every day\n"));
1065 else
1066 RTPrintf(List::tr("Check frequency: every %u days\n", "", ulValue), ulValue);
1067
1068 Bstr str;
1069 const char *psz;
1070 UpdateChannel_T enmUpdateChannel;
1071 ptrUpdateAgent->COMGETTER(Channel)(&enmUpdateChannel);
1072 switch (enmUpdateChannel)
1073 {
1074 case UpdateChannel_Stable:
1075 psz = List::tr("Stable: Maintenance and minor releases within the same major release");
1076 break;
1077 case UpdateChannel_All:
1078 psz = List::tr("All releases: All stable releases, including major versions");
1079 break;
1080 case UpdateChannel_WithBetas:
1081 psz = List::tr("With Betas: All stable and major releases, including beta versions");
1082 break;
1083 case UpdateChannel_WithTesting:
1084 psz = List::tr("With Testing: All stable, major and beta releases, including testing versions");
1085 break;
1086 default:
1087 psz = List::tr("Unset");
1088 break;
1089 }
1090 RTPrintf(List::tr("Channel: %s\n"), psz);
1091 ptrUpdateAgent->COMGETTER(RepositoryURL)(str.asOutParam());
1092 RTPrintf(List::tr("Repository: %ls\n"), str.raw());
1093 ptrUpdateAgent->COMGETTER(LastCheckDate)(str.asOutParam());
1094 RTPrintf(List::tr("Last check date: %ls\n"), str.raw());
1095
1096 return S_OK;
1097}
1098
1099static HRESULT listUpdateAgents(const ComPtr<IVirtualBox> &pVirtualBox)
1100{
1101 ComPtr<IHost> pHost;
1102 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), RTEXITCODE_FAILURE);
1103
1104 ComPtr<IUpdateAgent> pUpdateHost;
1105 CHECK_ERROR2I_RET(pHost, COMGETTER(UpdateHost)(pUpdateHost.asOutParam()), RTEXITCODE_FAILURE);
1106 /** @todo Add other update agents here. */
1107
1108 return listUpdateAgentConfig(pUpdateHost);
1109}
1110#endif /* VBOX_WITH_UPDATE_AGENT */
1111
1112/**
1113 * Helper for listDhcpServers() that shows a DHCP configuration.
1114 */
1115static HRESULT showDhcpConfig(ComPtr<IDHCPConfig> ptrConfig)
1116{
1117 HRESULT hrcRet = S_OK;
1118
1119 ULONG secs = 0;
1120 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MinLeaseTime)(&secs), hrcRet = hrcCheck);
1121 if (secs == 0)
1122 RTPrintf(List::tr(" minLeaseTime: default\n"));
1123 else
1124 RTPrintf(List::tr(" minLeaseTime: %u sec\n"), secs);
1125
1126 secs = 0;
1127 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(DefaultLeaseTime)(&secs), hrcRet = hrcCheck);
1128 if (secs == 0)
1129 RTPrintf(List::tr(" defaultLeaseTime: default\n"));
1130 else
1131 RTPrintf(List::tr(" defaultLeaseTime: %u sec\n"), secs);
1132
1133 secs = 0;
1134 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MaxLeaseTime)(&secs), hrcRet = hrcCheck);
1135 if (secs == 0)
1136 RTPrintf(List::tr(" maxLeaseTime: default\n"));
1137 else
1138 RTPrintf(List::tr(" maxLeaseTime: %u sec\n"), secs);
1139
1140 com::SafeArray<DHCPOption_T> Options;
1141 HRESULT hrc;
1142 CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(ForcedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1143 if (FAILED(hrc))
1144 RTPrintf(List::tr(" Forced options: %Rhrc\n"), hrc);
1145 else if (Options.size() == 0)
1146 RTPrintf(List::tr(" Forced options: None\n"));
1147 else
1148 {
1149 RTPrintf(List::tr(" Forced options: "));
1150 for (size_t i = 0; i < Options.size(); i++)
1151 RTPrintf(i ? ", %u" : "%u", Options[i]);
1152 RTPrintf("\n");
1153 }
1154
1155 CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(SuppressedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1156 if (FAILED(hrc))
1157 RTPrintf(List::tr(" Suppressed opt.s: %Rhrc\n"), hrc);
1158 else if (Options.size() == 0)
1159 RTPrintf(List::tr(" Suppressed opts.: None\n"));
1160 else
1161 {
1162 RTPrintf(List::tr(" Suppressed opts.: "));
1163 for (size_t i = 0; i < Options.size(); i++)
1164 RTPrintf(i ? ", %u" : "%u", Options[i]);
1165 RTPrintf("\n");
1166 }
1167
1168 com::SafeArray<DHCPOptionEncoding_T> Encodings;
1169 com::SafeArray<BSTR> Values;
1170 CHECK_ERROR2_STMT(hrc, ptrConfig, GetAllOptions(ComSafeArrayAsOutParam(Options),
1171 ComSafeArrayAsOutParam(Encodings),
1172 ComSafeArrayAsOutParam(Values)), hrcRet = hrc);
1173 if (FAILED(hrc))
1174 RTPrintf(List::tr(" DHCP options: %Rhrc\n"), hrc);
1175 else if (Options.size() != Encodings.size() || Options.size() != Values.size())
1176 {
1177 RTPrintf(List::tr(" DHCP options: Return count mismatch: %zu, %zu, %zu\n"),
1178 Options.size(), Encodings.size(), Values.size());
1179 hrcRet = E_FAIL;
1180 }
1181 else if (Options.size() == 0)
1182 RTPrintf(List::tr(" DHCP options: None\n"));
1183 else
1184 for (size_t i = 0; i < Options.size(); i++)
1185 {
1186 switch (Encodings[i])
1187 {
1188 case DHCPOptionEncoding_Normal:
1189 RTPrintf(List::tr(" %3d/legacy: %ls\n"), Options[i], Values[i]);
1190 break;
1191 case DHCPOptionEncoding_Hex:
1192 RTPrintf(" %3d/hex: %ls\n", Options[i], Values[i]);
1193 break;
1194 default:
1195 RTPrintf(" %3d/%u?: %ls\n", Options[i], Encodings[i], Values[i]);
1196 break;
1197 }
1198 }
1199
1200 return S_OK;
1201}
1202
1203
1204/**
1205 * List DHCP servers.
1206 *
1207 * @returns See produceList.
1208 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1209 */
1210static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox)
1211{
1212 HRESULT hrcRet = S_OK;
1213 com::SafeIfaceArray<IDHCPServer> DHCPServers;
1214 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(DHCPServers)), hrcCheck);
1215 for (size_t i = 0; i < DHCPServers.size(); ++i)
1216 {
1217 if (i > 0)
1218 RTPrintf("\n");
1219
1220 ComPtr<IDHCPServer> ptrDHCPServer = DHCPServers[i];
1221 Bstr bstr;
1222 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkName)(bstr.asOutParam()), hrcRet = hrcCheck);
1223 RTPrintf(List::tr("NetworkName: %ls\n"), bstr.raw());
1224
1225 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(IPAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1226 RTPrintf("Dhcpd IP: %ls\n", bstr.raw());
1227
1228 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(LowerIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1229 RTPrintf(List::tr("LowerIPAddress: %ls\n"), bstr.raw());
1230
1231 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(UpperIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1232 RTPrintf(List::tr("UpperIPAddress: %ls\n"), bstr.raw());
1233
1234 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkMask)(bstr.asOutParam()), hrcRet = hrcCheck);
1235 RTPrintf(List::tr("NetworkMask: %ls\n"), bstr.raw());
1236
1237 BOOL fEnabled = FALSE;
1238 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(Enabled)(&fEnabled), hrcRet = hrcCheck);
1239 RTPrintf(List::tr("Enabled: %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
1240
1241 /* Global configuration: */
1242 RTPrintf(List::tr("Global Configuration:\n"));
1243 HRESULT hrc;
1244 ComPtr<IDHCPGlobalConfig> ptrGlobal;
1245 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GlobalConfig)(ptrGlobal.asOutParam()), hrcRet = hrc);
1246 if (SUCCEEDED(hrc))
1247 {
1248 hrc = showDhcpConfig(ptrGlobal);
1249 if (FAILED(hrc))
1250 hrcRet = hrc;
1251 }
1252
1253 /* Group configurations: */
1254 com::SafeIfaceArray<IDHCPGroupConfig> Groups;
1255 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GroupConfigs)(ComSafeArrayAsOutParam(Groups)), hrcRet = hrc);
1256 if (FAILED(hrc))
1257 RTPrintf(List::tr("Groups: %Rrc\n"), hrc);
1258 else if (Groups.size() == 0)
1259 RTPrintf(List::tr("Groups: None\n"));
1260 else
1261 {
1262 for (size_t iGrp = 0; iGrp < Groups.size(); iGrp++)
1263 {
1264 CHECK_ERROR2I_STMT(Groups[iGrp], COMGETTER(Name)(bstr.asOutParam()), hrcRet = hrcCheck);
1265 RTPrintf(List::tr("Group: %ls\n"), bstr.raw());
1266
1267 com::SafeIfaceArray<IDHCPGroupCondition> Conditions;
1268 CHECK_ERROR2_STMT(hrc, Groups[iGrp], COMGETTER(Conditions)(ComSafeArrayAsOutParam(Conditions)), hrcRet = hrc);
1269 if (FAILED(hrc))
1270 RTPrintf(List::tr(" Conditions: %Rhrc\n"), hrc);
1271 else if (Conditions.size() == 0)
1272 RTPrintf(List::tr(" Conditions: None\n"));
1273 else
1274 for (size_t iCond = 0; iCond < Conditions.size(); iCond++)
1275 {
1276 BOOL fInclusive = TRUE;
1277 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Inclusive)(&fInclusive), hrcRet = hrc);
1278 DHCPGroupConditionType_T enmType = DHCPGroupConditionType_MAC;
1279 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Type)(&enmType), hrcRet = hrc);
1280 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Value)(bstr.asOutParam()), hrcRet = hrc);
1281
1282 RTPrintf(List::tr(" Conditions: %s %s %ls\n"),
1283 fInclusive ? List::tr("include") : List::tr("exclude"),
1284 enmType == DHCPGroupConditionType_MAC ? "MAC "
1285 : enmType == DHCPGroupConditionType_MACWildcard ? "MAC* "
1286 : enmType == DHCPGroupConditionType_vendorClassID ? "VendorCID "
1287 : enmType == DHCPGroupConditionType_vendorClassIDWildcard ? "VendorCID*"
1288 : enmType == DHCPGroupConditionType_userClassID ? "UserCID "
1289 : enmType == DHCPGroupConditionType_userClassIDWildcard ? "UserCID* "
1290 : "!UNKNOWN! ",
1291 bstr.raw());
1292 }
1293
1294 hrc = showDhcpConfig(Groups[iGrp]);
1295 if (FAILED(hrc))
1296 hrcRet = hrc;
1297 }
1298 Groups.setNull();
1299 }
1300
1301 /* Individual host / NIC configurations: */
1302 com::SafeIfaceArray<IDHCPIndividualConfig> Hosts;
1303 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(IndividualConfigs)(ComSafeArrayAsOutParam(Hosts)), hrcRet = hrc);
1304 if (FAILED(hrc))
1305 RTPrintf(List::tr("Individual Configs: %Rrc\n"), hrc);
1306 else if (Hosts.size() == 0)
1307 RTPrintf(List::tr("Individual Configs: None\n"));
1308 else
1309 {
1310 for (size_t iHost = 0; iHost < Hosts.size(); iHost++)
1311 {
1312 DHCPConfigScope_T enmScope = DHCPConfigScope_MAC;
1313 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Scope)(&enmScope), hrcRet = hrcCheck);
1314
1315 if (enmScope == DHCPConfigScope_MAC)
1316 {
1317 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MACAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1318 RTPrintf(List::tr("Individual Config: MAC %ls\n"), bstr.raw());
1319 }
1320 else
1321 {
1322 ULONG uSlot = 0;
1323 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Slot)(&uSlot), hrcRet = hrcCheck);
1324 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MachineId)(bstr.asOutParam()), hrcRet = hrcCheck);
1325 Bstr bstrMACAddress;
1326 hrc = Hosts[iHost]->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); /* No CHECK_ERROR2 stuff! */
1327 if (SUCCEEDED(hrc))
1328 RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %ls\n"), bstr.raw(), uSlot,
1329 bstrMACAddress.raw());
1330 else
1331 RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %Rhrc\n"), bstr.raw(), uSlot, hrc);
1332 }
1333
1334 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(FixedAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1335 if (bstr.isNotEmpty())
1336 RTPrintf(List::tr(" Fixed Address: %ls\n"), bstr.raw());
1337 else
1338 RTPrintf(List::tr(" Fixed Address: dynamic\n"));
1339
1340 hrc = showDhcpConfig(Hosts[iHost]);
1341 if (FAILED(hrc))
1342 hrcRet = hrc;
1343 }
1344 Hosts.setNull();
1345 }
1346 }
1347
1348 return hrcRet;
1349}
1350
1351/**
1352 * List extension packs.
1353 *
1354 * @returns See produceList.
1355 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1356 */
1357static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
1358{
1359 ComObjPtr<IExtPackManager> ptrExtPackMgr;
1360 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
1361
1362 SafeIfaceArray<IExtPack> extPacks;
1363 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
1364 RTPrintf(List::tr("Extension Packs: %u\n"), extPacks.size());
1365
1366 HRESULT hrc = S_OK;
1367 for (size_t i = 0; i < extPacks.size(); i++)
1368 {
1369 /* Read all the properties. */
1370 Bstr bstrName;
1371 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
1372 Bstr bstrDesc;
1373 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
1374 Bstr bstrVersion;
1375 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
1376 ULONG uRevision;
1377 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
1378 Bstr bstrEdition;
1379 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
1380 Bstr bstrVrdeModule;
1381 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
1382 Bstr bstrCryptoModule;
1383 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(CryptoModule)(bstrCryptoModule.asOutParam()),hrc=hrcCheck; bstrCryptoModule.setNull());
1384 BOOL fUsable;
1385 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
1386 Bstr bstrWhy;
1387 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
1388
1389 /* Display them. */
1390 if (i)
1391 RTPrintf("\n");
1392 RTPrintf(List::tr(
1393 "Pack no.%2zu: %ls\n"
1394 "Version: %ls\n"
1395 "Revision: %u\n"
1396 "Edition: %ls\n"
1397 "Description: %ls\n"
1398 "VRDE Module: %ls\n"
1399 "Crypto Module: %ls\n"
1400 "Usable: %RTbool\n"
1401 "Why unusable: %ls\n"),
1402 i, bstrName.raw(),
1403 bstrVersion.raw(),
1404 uRevision,
1405 bstrEdition.raw(),
1406 bstrDesc.raw(),
1407 bstrVrdeModule.raw(),
1408 bstrCryptoModule.raw(),
1409 fUsable != FALSE,
1410 bstrWhy.raw());
1411
1412 /* Query plugins and display them. */
1413 }
1414 return hrc;
1415}
1416
1417
1418/**
1419 * List machine groups.
1420 *
1421 * @returns See produceList.
1422 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1423 */
1424static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
1425{
1426 SafeArray<BSTR> groups;
1427 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
1428
1429 for (size_t i = 0; i < groups.size(); i++)
1430 {
1431 RTPrintf("\"%ls\"\n", groups[i]);
1432 }
1433 return S_OK;
1434}
1435
1436
1437/**
1438 * List video capture devices.
1439 *
1440 * @returns See produceList.
1441 * @param pVirtualBox Reference to the IVirtualBox pointer.
1442 */
1443static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> &pVirtualBox)
1444{
1445 HRESULT hrc;
1446 ComPtr<IHost> host;
1447 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1448 com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
1449 CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
1450 RTPrintf(List::tr("Video Input Devices: %u\n"), hostVideoInputDevices.size());
1451 for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
1452 {
1453 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
1454 Bstr name;
1455 p->COMGETTER(Name)(name.asOutParam());
1456 Bstr path;
1457 p->COMGETTER(Path)(path.asOutParam());
1458 Bstr alias;
1459 p->COMGETTER(Alias)(alias.asOutParam());
1460 RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
1461 }
1462 return hrc;
1463}
1464
1465/**
1466 * List supported screen shot formats.
1467 *
1468 * @returns See produceList.
1469 * @param pVirtualBox Reference to the IVirtualBox pointer.
1470 */
1471static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> &pVirtualBox)
1472{
1473 HRESULT hrc = S_OK;
1474 ComPtr<ISystemProperties> systemProperties;
1475 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
1476 com::SafeArray<BitmapFormat_T> formats;
1477 CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
1478
1479 RTPrintf(List::tr("Supported %d screen shot formats:\n", "", formats.size()), formats.size());
1480 for (size_t i = 0; i < formats.size(); ++i)
1481 {
1482 uint32_t u32Format = (uint32_t)formats[i];
1483 char szFormat[5];
1484 szFormat[0] = RT_BYTE1(u32Format);
1485 szFormat[1] = RT_BYTE2(u32Format);
1486 szFormat[2] = RT_BYTE3(u32Format);
1487 szFormat[3] = RT_BYTE4(u32Format);
1488 szFormat[4] = 0;
1489 RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
1490 }
1491 return hrc;
1492}
1493
1494/**
1495 * List available cloud providers.
1496 *
1497 * @returns See produceList.
1498 * @param pVirtualBox Reference to the IVirtualBox pointer.
1499 */
1500static HRESULT listCloudProviders(const ComPtr<IVirtualBox> &pVirtualBox)
1501{
1502 HRESULT hrc = S_OK;
1503 ComPtr<ICloudProviderManager> pCloudProviderManager;
1504 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1505 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1506 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1507
1508 RTPrintf(List::tr("Supported %d cloud providers:\n", "", apCloudProviders.size()), apCloudProviders.size());
1509 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1510 {
1511 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1512 Bstr bstrProviderName;
1513 pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
1514 RTPrintf(List::tr("Name: %ls\n"), bstrProviderName.raw());
1515 pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
1516 RTPrintf(List::tr("Short Name: %ls\n"), bstrProviderName.raw());
1517 Bstr bstrProviderID;
1518 pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
1519 RTPrintf("GUID: %ls\n", bstrProviderID.raw());
1520
1521 RTPrintf("\n");
1522 }
1523 return hrc;
1524}
1525
1526
1527/**
1528 * List all available cloud profiles (by iterating over the cloud providers).
1529 *
1530 * @returns See produceList.
1531 * @param pVirtualBox Reference to the IVirtualBox pointer.
1532 * @param fOptLong If true, list all profile properties.
1533 */
1534static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> &pVirtualBox, bool fOptLong)
1535{
1536 HRESULT hrc = S_OK;
1537 ComPtr<ICloudProviderManager> pCloudProviderManager;
1538 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1539 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1540 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1541
1542 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1543 {
1544 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1545 com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
1546 CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
1547 for (size_t j = 0; j < apCloudProfiles.size(); ++j)
1548 {
1549 ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
1550 Bstr bstrProfileName;
1551 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
1552 RTPrintf(List::tr("Name: %ls\n"), bstrProfileName.raw());
1553 Bstr bstrProviderID;
1554 pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
1555 RTPrintf(List::tr("Provider GUID: %ls\n"), bstrProviderID.raw());
1556
1557 if (fOptLong)
1558 {
1559 com::SafeArray<BSTR> names;
1560 com::SafeArray<BSTR> values;
1561 pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1562 size_t cNames = names.size();
1563 size_t cValues = values.size();
1564 bool fFirst = true;
1565 for (size_t k = 0; k < cNames; k++)
1566 {
1567 Bstr value;
1568 if (k < cValues)
1569 value = values[k];
1570 RTPrintf("%s%ls=%ls\n",
1571 fFirst ? List::tr("Property: ") : " ",
1572 names[k], value.raw());
1573 fFirst = false;
1574 }
1575 }
1576
1577 RTPrintf("\n");
1578 }
1579 }
1580 return hrc;
1581}
1582
1583static HRESULT displayCPUProfile(ICPUProfile *pProfile, size_t idx, int cchIdx, bool fOptLong, HRESULT hrc)
1584{
1585 /* Retrieve the attributes needed for both long and short display. */
1586 Bstr bstrName;
1587 CHECK_ERROR2I_RET(pProfile, COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1588
1589 CPUArchitecture_T enmArchitecture = CPUArchitecture_Any;
1590 CHECK_ERROR2I_RET(pProfile, COMGETTER(Architecture)(&enmArchitecture), hrcCheck);
1591 const char *pszArchitecture = "???";
1592 switch (enmArchitecture)
1593 {
1594 case CPUArchitecture_x86: pszArchitecture = "x86"; break;
1595 case CPUArchitecture_AMD64: pszArchitecture = "AMD64"; break;
1596 case CPUArchitecture_ARMv8_32: pszArchitecture = "ARMv8 (32-bit only)"; break;
1597 case CPUArchitecture_ARMv8_64: pszArchitecture = "ARMv8 (64-bit)"; break;
1598#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1599 case CPUArchitecture_32BitHack:
1600#endif
1601 case CPUArchitecture_Any:
1602 break;
1603 }
1604
1605 /* Print what we've got. */
1606 if (!fOptLong)
1607 RTPrintf("#%0*zu: %ls [%s]\n", cchIdx, idx, bstrName.raw(), pszArchitecture);
1608 else
1609 {
1610 RTPrintf(List::tr("CPU Profile #%02zu:\n"), idx);
1611 RTPrintf(List::tr(" Architecture: %s\n"), pszArchitecture);
1612 RTPrintf(List::tr(" Name: %ls\n"), bstrName.raw());
1613 CHECK_ERROR2I_RET(pProfile, COMGETTER(FullName)(bstrName.asOutParam()), hrcCheck);
1614 RTPrintf(List::tr(" Full Name: %ls\n"), bstrName.raw());
1615 }
1616 return hrc;
1617}
1618
1619
1620/**
1621 * List all CPU profiles.
1622 *
1623 * @returns See produceList.
1624 * @param ptrVirtualBox Reference to the smart IVirtualBox pointer.
1625 * @param fOptLong If true, list all profile properties.
1626 * @param fOptSorted Sort the output if true, otherwise display in
1627 * system order.
1628 */
1629static HRESULT listCPUProfiles(const ComPtr<IVirtualBox> &ptrVirtualBox, bool fOptLong, bool fOptSorted)
1630{
1631 ComPtr<ISystemProperties> ptrSysProps;
1632 CHECK_ERROR2I_RET(ptrVirtualBox, COMGETTER(SystemProperties)(ptrSysProps.asOutParam()), hrcCheck);
1633 com::SafeIfaceArray<ICPUProfile> aCPUProfiles;
1634 CHECK_ERROR2I_RET(ptrSysProps, GetCPUProfiles(CPUArchitecture_Any, Bstr().raw(),
1635 ComSafeArrayAsOutParam(aCPUProfiles)), hrcCheck);
1636
1637 int const cchIdx = 1 + (aCPUProfiles.size() >= 10) + (aCPUProfiles.size() >= 100);
1638
1639 HRESULT hrc = S_OK;
1640 if (!fOptSorted)
1641 for (size_t i = 0; i < aCPUProfiles.size(); i++)
1642 hrc = displayCPUProfile(aCPUProfiles[i], i, cchIdx, fOptLong, hrc);
1643 else
1644 {
1645 std::vector<std::pair<com::Bstr, ICPUProfile *> > vecSortedProfiles;
1646 for (size_t i = 0; i < aCPUProfiles.size(); ++i)
1647 {
1648 Bstr bstrName;
1649 CHECK_ERROR2I_RET(aCPUProfiles[i], COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1650 try
1651 {
1652 vecSortedProfiles.push_back(std::pair<com::Bstr, ICPUProfile *>(bstrName, aCPUProfiles[i]));
1653 }
1654 catch (std::bad_alloc &)
1655 {
1656 return E_OUTOFMEMORY;
1657 }
1658 }
1659
1660 std::sort(vecSortedProfiles.begin(), vecSortedProfiles.end());
1661
1662 for (size_t i = 0; i < vecSortedProfiles.size(); i++)
1663 hrc = displayCPUProfile(vecSortedProfiles[i].second, i, cchIdx, fOptLong, hrc);
1664 }
1665
1666 return hrc;
1667}
1668
1669
1670/**
1671 * Translates PartitionType_T to a string if possible.
1672 * @returns read-only string if known value, @a pszUnknown if not.
1673 */
1674static const char *PartitionTypeToString(PartitionType_T enmType, const char *pszUnknown)
1675{
1676#define MY_CASE_STR(a_Type) case RT_CONCAT(PartitionType_,a_Type): return #a_Type
1677 switch (enmType)
1678 {
1679 MY_CASE_STR(Empty);
1680 MY_CASE_STR(FAT12);
1681 MY_CASE_STR(FAT16);
1682 MY_CASE_STR(FAT);
1683 MY_CASE_STR(IFS);
1684 MY_CASE_STR(FAT32CHS);
1685 MY_CASE_STR(FAT32LBA);
1686 MY_CASE_STR(FAT16B);
1687 MY_CASE_STR(Extended);
1688 MY_CASE_STR(WindowsRE);
1689 MY_CASE_STR(LinuxSwapOld);
1690 MY_CASE_STR(LinuxOld);
1691 MY_CASE_STR(DragonFlyBSDSlice);
1692 MY_CASE_STR(LinuxSwap);
1693 MY_CASE_STR(Linux);
1694 MY_CASE_STR(LinuxExtended);
1695 MY_CASE_STR(LinuxLVM);
1696 MY_CASE_STR(BSDSlice);
1697 MY_CASE_STR(AppleUFS);
1698 MY_CASE_STR(AppleHFS);
1699 MY_CASE_STR(Solaris);
1700 MY_CASE_STR(GPT);
1701 MY_CASE_STR(EFI);
1702 MY_CASE_STR(Unknown);
1703 MY_CASE_STR(MBR);
1704 MY_CASE_STR(iFFS);
1705 MY_CASE_STR(SonyBoot);
1706 MY_CASE_STR(LenovoBoot);
1707 MY_CASE_STR(WindowsMSR);
1708 MY_CASE_STR(WindowsBasicData);
1709 MY_CASE_STR(WindowsLDMMeta);
1710 MY_CASE_STR(WindowsLDMData);
1711 MY_CASE_STR(WindowsRecovery);
1712 MY_CASE_STR(WindowsStorageSpaces);
1713 MY_CASE_STR(WindowsStorageReplica);
1714 MY_CASE_STR(IBMGPFS);
1715 MY_CASE_STR(LinuxData);
1716 MY_CASE_STR(LinuxRAID);
1717 MY_CASE_STR(LinuxRootX86);
1718 MY_CASE_STR(LinuxRootAMD64);
1719 MY_CASE_STR(LinuxRootARM32);
1720 MY_CASE_STR(LinuxRootARM64);
1721 MY_CASE_STR(LinuxHome);
1722 MY_CASE_STR(LinuxSrv);
1723 MY_CASE_STR(LinuxPlainDmCrypt);
1724 MY_CASE_STR(LinuxLUKS);
1725 MY_CASE_STR(LinuxReserved);
1726 MY_CASE_STR(FreeBSDBoot);
1727 MY_CASE_STR(FreeBSDData);
1728 MY_CASE_STR(FreeBSDSwap);
1729 MY_CASE_STR(FreeBSDUFS);
1730 MY_CASE_STR(FreeBSDVinum);
1731 MY_CASE_STR(FreeBSDZFS);
1732 MY_CASE_STR(FreeBSDUnknown);
1733 MY_CASE_STR(AppleHFSPlus);
1734 MY_CASE_STR(AppleAPFS);
1735 MY_CASE_STR(AppleRAID);
1736 MY_CASE_STR(AppleRAIDOffline);
1737 MY_CASE_STR(AppleBoot);
1738 MY_CASE_STR(AppleLabel);
1739 MY_CASE_STR(AppleTvRecovery);
1740 MY_CASE_STR(AppleCoreStorage);
1741 MY_CASE_STR(SoftRAIDStatus);
1742 MY_CASE_STR(SoftRAIDScratch);
1743 MY_CASE_STR(SoftRAIDVolume);
1744 MY_CASE_STR(SoftRAIDCache);
1745 MY_CASE_STR(AppleUnknown);
1746 MY_CASE_STR(SolarisBoot);
1747 MY_CASE_STR(SolarisRoot);
1748 MY_CASE_STR(SolarisSwap);
1749 MY_CASE_STR(SolarisBackup);
1750 MY_CASE_STR(SolarisUsr);
1751 MY_CASE_STR(SolarisVar);
1752 MY_CASE_STR(SolarisHome);
1753 MY_CASE_STR(SolarisAltSector);
1754 MY_CASE_STR(SolarisReserved);
1755 MY_CASE_STR(SolarisUnknown);
1756 MY_CASE_STR(NetBSDSwap);
1757 MY_CASE_STR(NetBSDFFS);
1758 MY_CASE_STR(NetBSDLFS);
1759 MY_CASE_STR(NetBSDRAID);
1760 MY_CASE_STR(NetBSDConcatenated);
1761 MY_CASE_STR(NetBSDEncrypted);
1762 MY_CASE_STR(NetBSDUnknown);
1763 MY_CASE_STR(ChromeOSKernel);
1764 MY_CASE_STR(ChromeOSRootFS);
1765 MY_CASE_STR(ChromeOSFuture);
1766 MY_CASE_STR(ContLnxUsr);
1767 MY_CASE_STR(ContLnxRoot);
1768 MY_CASE_STR(ContLnxReserved);
1769 MY_CASE_STR(ContLnxRootRAID);
1770 MY_CASE_STR(HaikuBFS);
1771 MY_CASE_STR(MidntBSDBoot);
1772 MY_CASE_STR(MidntBSDData);
1773 MY_CASE_STR(MidntBSDSwap);
1774 MY_CASE_STR(MidntBSDUFS);
1775 MY_CASE_STR(MidntBSDVium);
1776 MY_CASE_STR(MidntBSDZFS);
1777 MY_CASE_STR(MidntBSDUnknown);
1778 MY_CASE_STR(OpenBSDData);
1779 MY_CASE_STR(QNXPowerSafeFS);
1780 MY_CASE_STR(Plan9);
1781 MY_CASE_STR(VMWareVMKCore);
1782 MY_CASE_STR(VMWareVMFS);
1783 MY_CASE_STR(VMWareReserved);
1784 MY_CASE_STR(VMWareUnknown);
1785 MY_CASE_STR(AndroidX86Bootloader);
1786 MY_CASE_STR(AndroidX86Bootloader2);
1787 MY_CASE_STR(AndroidX86Boot);
1788 MY_CASE_STR(AndroidX86Recovery);
1789 MY_CASE_STR(AndroidX86Misc);
1790 MY_CASE_STR(AndroidX86Metadata);
1791 MY_CASE_STR(AndroidX86System);
1792 MY_CASE_STR(AndroidX86Cache);
1793 MY_CASE_STR(AndroidX86Data);
1794 MY_CASE_STR(AndroidX86Persistent);
1795 MY_CASE_STR(AndroidX86Vendor);
1796 MY_CASE_STR(AndroidX86Config);
1797 MY_CASE_STR(AndroidX86Factory);
1798 MY_CASE_STR(AndroidX86FactoryAlt);
1799 MY_CASE_STR(AndroidX86Fastboot);
1800 MY_CASE_STR(AndroidX86OEM);
1801 MY_CASE_STR(AndroidARMMeta);
1802 MY_CASE_STR(AndroidARMExt);
1803 MY_CASE_STR(ONIEBoot);
1804 MY_CASE_STR(ONIEConfig);
1805 MY_CASE_STR(PowerPCPrep);
1806 MY_CASE_STR(XDGShrBootConfig);
1807 MY_CASE_STR(CephBlock);
1808 MY_CASE_STR(CephBlockDB);
1809 MY_CASE_STR(CephBlockDBDmc);
1810 MY_CASE_STR(CephBlockDBDmcLUKS);
1811 MY_CASE_STR(CephBlockDmc);
1812 MY_CASE_STR(CephBlockDmcLUKS);
1813 MY_CASE_STR(CephBlockWALog);
1814 MY_CASE_STR(CephBlockWALogDmc);
1815 MY_CASE_STR(CephBlockWALogDmcLUKS);
1816 MY_CASE_STR(CephDisk);
1817 MY_CASE_STR(CephDiskDmc);
1818 MY_CASE_STR(CephJournal);
1819 MY_CASE_STR(CephJournalDmc);
1820 MY_CASE_STR(CephJournalDmcLUKS);
1821 MY_CASE_STR(CephLockbox);
1822 MY_CASE_STR(CephMultipathBlock1);
1823 MY_CASE_STR(CephMultipathBlock2);
1824 MY_CASE_STR(CephMultipathBlockDB);
1825 MY_CASE_STR(CephMultipathBLockWALog);
1826 MY_CASE_STR(CephMultipathJournal);
1827 MY_CASE_STR(CephMultipathOSD);
1828 MY_CASE_STR(CephOSD);
1829 MY_CASE_STR(CephOSDDmc);
1830 MY_CASE_STR(CephOSDDmcLUKS);
1831#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1832 case PartitionType_32BitHack: break;
1833#endif
1834 /* no default! */
1835 }
1836#undef MY_CASE_STR
1837 return pszUnknown;
1838}
1839
1840
1841/**
1842 * List all available host drives with their partitions.
1843 *
1844 * @returns See produceList.
1845 * @param pVirtualBox Reference to the IVirtualBox pointer.
1846 * @param fOptLong Long listing or human readable.
1847 */
1848static HRESULT listHostDrives(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
1849{
1850 HRESULT hrc = S_OK;
1851 ComPtr<IHost> pHost;
1852 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), hrcCheck);
1853 com::SafeIfaceArray<IHostDrive> apHostDrives;
1854 CHECK_ERROR2I_RET(pHost, COMGETTER(HostDrives)(ComSafeArrayAsOutParam(apHostDrives)), hrcCheck);
1855 for (size_t i = 0; i < apHostDrives.size(); ++i)
1856 {
1857 ComPtr<IHostDrive> pHostDrive = apHostDrives[i];
1858
1859 /* The drivePath and model attributes are accessible even when the object
1860 is in 'limited' mode. */
1861 com::Bstr bstrDrivePath;
1862 CHECK_ERROR(pHostDrive,COMGETTER(DrivePath)(bstrDrivePath.asOutParam()));
1863 if (SUCCEEDED(hrc))
1864 RTPrintf(List::tr("%sDrive: %ls\n"), i > 0 ? "\n" : "", bstrDrivePath.raw());
1865 else
1866 RTPrintf(List::tr("%sDrive: %Rhrc\n"), i > 0 ? "\n" : "", hrc);
1867
1868 com::Bstr bstrModel;
1869 CHECK_ERROR(pHostDrive,COMGETTER(Model)(bstrModel.asOutParam()));
1870 if (FAILED(hrc))
1871 RTPrintf(List::tr("Model: %Rhrc\n"), hrc);
1872 else if (bstrModel.isNotEmpty())
1873 RTPrintf(List::tr("Model: \"%ls\"\n"), bstrModel.raw());
1874 else
1875 RTPrintf(List::tr("Model: unknown/inaccessible\n"));
1876
1877 /* The other attributes are not accessible in limited mode and will fail
1878 with E_ACCESSDENIED. Typically means the user cannot read the drive. */
1879 com::Bstr bstrUuidDisk;
1880 hrc = pHostDrive->COMGETTER(Uuid)(bstrUuidDisk.asOutParam());
1881 if (SUCCEEDED(hrc) && !com::Guid(bstrUuidDisk).isZero())
1882 RTPrintf("UUID: %ls\n", bstrUuidDisk.raw());
1883 else if (hrc == E_ACCESSDENIED)
1884 {
1885 RTPrintf(List::tr("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n"),
1886 bstrDrivePath.raw());
1887 continue;
1888 }
1889 else if (FAILED(hrc))
1890 {
1891 RTPrintf("UUID: %Rhrc\n", hrc);
1892 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1893 }
1894
1895 LONG64 cbSize = 0;
1896 hrc = pHostDrive->COMGETTER(Size)(&cbSize);
1897 if (SUCCEEDED(hrc) && fOptLong)
1898 RTPrintf(List::tr("Size: %llu bytes (%Rhcb)\n", "", cbSize), cbSize, cbSize);
1899 else if (SUCCEEDED(hrc))
1900 RTPrintf(List::tr("Size: %Rhcb\n"), cbSize);
1901 else
1902 {
1903 RTPrintf(List::tr("Size: %Rhrc\n"), hrc);
1904 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1905 }
1906
1907 ULONG cbSectorSize = 0;
1908 hrc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
1909 if (SUCCEEDED(hrc))
1910 RTPrintf(List::tr("Sector Size: %u bytes\n", "", cbSectorSize), cbSectorSize);
1911 else
1912 {
1913 RTPrintf(List::tr("Sector Size: %Rhrc\n"), hrc);
1914 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1915 }
1916
1917 PartitioningType_T partitioningType = (PartitioningType_T)9999;
1918 hrc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
1919 if (SUCCEEDED(hrc))
1920 RTPrintf(List::tr("Scheme: %s\n"), partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
1921 else
1922 {
1923 RTPrintf(List::tr("Scheme: %Rhrc\n"), hrc);
1924 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1925 }
1926
1927 com::SafeIfaceArray<IHostDrivePartition> apHostDrivesPartitions;
1928 hrc = pHostDrive->COMGETTER(Partitions)(ComSafeArrayAsOutParam(apHostDrivesPartitions));
1929 if (FAILED(hrc))
1930 {
1931 RTPrintf(List::tr("Partitions: %Rhrc\n"), hrc);
1932 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1933 }
1934 else if (apHostDrivesPartitions.size() == 0)
1935 RTPrintf(List::tr("Partitions: None (or not able to grok them).\n"));
1936 else if (partitioningType == PartitioningType_MBR)
1937 {
1938 if (fOptLong)
1939 RTPrintf(List::tr("Partitions: First Last\n"
1940 "## Type Byte Size Byte Offset Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1941 else
1942 RTPrintf(List::tr("Partitions: First Last\n"
1943 "## Type Size Start Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1944 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1945 {
1946 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1947
1948 ULONG idx = 0;
1949 CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
1950 ULONG uType = 0;
1951 CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeMBR)(&uType));
1952 ULONG uStartCylinder = 0;
1953 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartCylinder)(&uStartCylinder));
1954 ULONG uStartHead = 0;
1955 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartHead)(&uStartHead));
1956 ULONG uStartSector = 0;
1957 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartSector)(&uStartSector));
1958 ULONG uEndCylinder = 0;
1959 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndCylinder)(&uEndCylinder));
1960 ULONG uEndHead = 0;
1961 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndHead)(&uEndHead));
1962 ULONG uEndSector = 0;
1963 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndSector)(&uEndSector));
1964 cbSize = 0;
1965 CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
1966 LONG64 offStart = 0;
1967 CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
1968 BOOL fActive = 0;
1969 CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
1970 PartitionType_T enmType = PartitionType_Unknown;
1971 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1972
1973 /* Max size & offset here is around 16TiB with 4KiB sectors. */
1974 if (fOptLong) /* cb/off: max 16TiB; idx: max 64. */
1975 RTPrintf("%2u %02x %14llu %14llu %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1976 idx, uType, cbSize, offStart,
1977 uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1978 fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1979 else
1980 RTPrintf("%2u %02x %8Rhcb %8Rhcb %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1981 idx, uType, (uint64_t)cbSize, (uint64_t)offStart,
1982 uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1983 fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1984 }
1985 }
1986 else /* GPT */
1987 {
1988 /* Determin the max partition type length to try reduce the table width: */
1989 size_t cchMaxType = 0;
1990 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1991 {
1992 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1993 PartitionType_T enmType = PartitionType_Unknown;
1994 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1995 size_t const cchTypeNm = strlen(PartitionTypeToString(enmType, "e530bf6d-2754-4e9d-b260-60a5d0b80457"));
1996 cchMaxType = RT_MAX(cchTypeNm, cchMaxType);
1997 }
1998 cchMaxType = RT_MIN(cchMaxType, RTUUID_STR_LENGTH);
1999
2000 if (fOptLong)
2001 RTPrintf(List::tr(
2002 "Partitions:\n"
2003 "## %-*s Uuid Byte Size Byte Offset Active Name\n"),
2004 (int)cchMaxType, List::tr("Type"));
2005 else
2006 RTPrintf(List::tr(
2007 "Partitions:\n"
2008 "## %-*s Uuid Size Start Active Name\n"),
2009 (int)cchMaxType, List::tr("Type"));
2010
2011 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
2012 {
2013 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
2014
2015 ULONG idx = 0;
2016 CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
2017 com::Bstr bstrUuidType;
2018 CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeUuid)(bstrUuidType.asOutParam()));
2019 com::Bstr bstrUuidPartition;
2020 CHECK_ERROR(pHostDrivePartition, COMGETTER(Uuid)(bstrUuidPartition.asOutParam()));
2021 cbSize = 0;
2022 CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
2023 LONG64 offStart = 0;
2024 CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
2025 BOOL fActive = 0;
2026 CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
2027 com::Bstr bstrName;
2028 CHECK_ERROR(pHostDrivePartition, COMGETTER(Name)(bstrName.asOutParam()));
2029
2030 PartitionType_T enmType = PartitionType_Unknown;
2031 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
2032
2033 Utf8Str strTypeConv;
2034 const char *pszTypeNm = PartitionTypeToString(enmType, NULL);
2035 if (!pszTypeNm)
2036 pszTypeNm = (strTypeConv = bstrUuidType).c_str();
2037 else if (strlen(pszTypeNm) >= RTUUID_STR_LENGTH /* includes '\0' */)
2038 pszTypeNm -= RTUUID_STR_LENGTH - 1 - strlen(pszTypeNm);
2039
2040 if (fOptLong)
2041 RTPrintf("%2u %-*s %36ls %19llu %19llu %-3s %ls\n", idx, cchMaxType, pszTypeNm,
2042 bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
2043 bstrName.raw());
2044 else
2045 RTPrintf("%2u %-*s %36ls %8Rhcb %8Rhcb %-3s %ls\n", idx, cchMaxType, pszTypeNm,
2046 bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
2047 bstrName.raw());
2048 }
2049 }
2050 }
2051 return hrc;
2052}
2053
2054
2055/**
2056 * The type of lists we can produce.
2057 */
2058enum ListType_T
2059{
2060 kListNotSpecified = 1000,
2061 kListVMs,
2062 kListRunningVMs,
2063 kListOsTypes,
2064 kListOsSubtypes,
2065 kListHostDvds,
2066 kListHostFloppies,
2067 kListInternalNetworks,
2068 kListBridgedInterfaces,
2069#if defined(VBOX_WITH_NETFLT)
2070 kListHostOnlyInterfaces,
2071#endif
2072#if defined(VBOX_WITH_VMNET)
2073 kListHostOnlyNetworks,
2074#endif
2075#if defined(VBOX_WITH_CLOUD_NET)
2076 kListCloudNetworks,
2077#endif
2078 kListHostCpuIDs,
2079 kListHostInfo,
2080 kListHddBackends,
2081 kListHdds,
2082 kListDvds,
2083 kListFloppies,
2084 kListUsbHost,
2085 kListUsbFilters,
2086 kListSystemProperties,
2087#if defined(VBOX_WITH_UPDATE_AGENT)
2088 kListUpdateAgents,
2089#endif
2090 kListDhcpServers,
2091 kListExtPacks,
2092 kListGroups,
2093 kListNatNetworks,
2094 kListVideoInputDevices,
2095 kListScreenShotFormats,
2096 kListCloudProviders,
2097 kListCloudProfiles,
2098 kListCPUProfiles,
2099 kListHostDrives
2100};
2101
2102
2103/**
2104 * Produces the specified listing.
2105 *
2106 * @returns S_OK or some COM error code that has been reported in full.
2107 * @param enmList The list to produce.
2108 * @param fOptLong Long (@c true) or short list format.
2109 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
2110 */
2111static HRESULT produceList(enum ListType_T enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
2112{
2113 HRESULT hrc = S_OK;
2114 switch (enmCommand)
2115 {
2116 case kListNotSpecified:
2117 AssertFailed();
2118 return E_FAIL;
2119
2120 case kListVMs:
2121 {
2122 /*
2123 * Get the list of all registered VMs
2124 */
2125 com::SafeIfaceArray<IMachine> machines;
2126 hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2127 if (SUCCEEDED(hrc))
2128 {
2129 /*
2130 * Display it.
2131 */
2132 if (!fOptSorted)
2133 {
2134 for (size_t i = 0; i < machines.size(); ++i)
2135 if (machines[i])
2136 hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2137 }
2138 else
2139 {
2140 /*
2141 * Sort the list by name before displaying it.
2142 */
2143 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
2144 for (size_t i = 0; i < machines.size(); ++i)
2145 {
2146 IMachine *pMachine = machines[i];
2147 if (pMachine) /* no idea why we need to do this... */
2148 {
2149 Bstr bstrName;
2150 pMachine->COMGETTER(Name)(bstrName.asOutParam());
2151 sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
2152 }
2153 }
2154
2155 std::sort(sortedMachines.begin(), sortedMachines.end());
2156
2157 for (size_t i = 0; i < sortedMachines.size(); ++i)
2158 hrc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2159 }
2160 }
2161 break;
2162 }
2163
2164 case kListRunningVMs:
2165 {
2166 /*
2167 * Get the list of all _running_ VMs
2168 */
2169 com::SafeIfaceArray<IMachine> machines;
2170 hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2171 com::SafeArray<MachineState_T> states;
2172 if (SUCCEEDED(hrc))
2173 hrc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
2174 if (SUCCEEDED(hrc))
2175 {
2176 /*
2177 * Iterate through the collection
2178 */
2179 for (size_t i = 0; i < machines.size(); ++i)
2180 {
2181 if (machines[i])
2182 {
2183 MachineState_T machineState = states[i];
2184 switch (machineState)
2185 {
2186 case MachineState_Running:
2187 case MachineState_Teleporting:
2188 case MachineState_LiveSnapshotting:
2189 case MachineState_Paused:
2190 case MachineState_TeleportingPausedVM:
2191 hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2192 break;
2193 default: break; /* Shut up MSC */
2194 }
2195 }
2196 }
2197 }
2198 break;
2199 }
2200
2201 case kListOsTypes:
2202 {
2203 com::SafeIfaceArray<IGuestOSType> coll;
2204 hrc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
2205 if (SUCCEEDED(hrc))
2206 listGuestOSTypes(coll);
2207 break;
2208 }
2209
2210 case kListOsSubtypes:
2211 {
2212 com::SafeArray<BSTR> GuestOSFamilies;
2213 CHECK_ERROR(pVirtualBox, COMGETTER(GuestOSFamilies)(ComSafeArrayAsOutParam(GuestOSFamilies)));
2214 if (SUCCEEDED(hrc))
2215 {
2216 for (size_t i = 0; i < GuestOSFamilies.size(); ++i)
2217 {
2218 const Bstr bstrOSFamily = GuestOSFamilies[i];
2219 com::SafeArray<BSTR> GuestOSSubtypes;
2220 CHECK_ERROR(pVirtualBox,
2221 GetGuestOSSubtypesByFamilyId(bstrOSFamily.raw(),
2222 ComSafeArrayAsOutParam(GuestOSSubtypes)));
2223 if (SUCCEEDED(hrc))
2224 {
2225 RTPrintf("%ls\n", bstrOSFamily.raw());
2226 for (size_t j = 0; j < GuestOSSubtypes.size(); ++j)
2227 {
2228 RTPrintf("\t%ls\n", GuestOSSubtypes[j]);
2229 com::SafeArray<BSTR> GuestOSDescs;
2230 const Bstr bstrOSSubtype = GuestOSSubtypes[j];
2231 CHECK_ERROR(pVirtualBox,
2232 GetGuestOSDescsBySubtype(bstrOSSubtype.raw(),
2233 ComSafeArrayAsOutParam(GuestOSDescs)));
2234 if (SUCCEEDED(hrc))
2235 for (size_t k = 0; k < GuestOSDescs.size(); ++k)
2236 RTPrintf("\t\t%ls\n", GuestOSDescs[k]);
2237 }
2238 }
2239 }
2240 }
2241 break;
2242 }
2243
2244 case kListHostDvds:
2245 {
2246 ComPtr<IHost> host;
2247 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2248 com::SafeIfaceArray<IMedium> coll;
2249 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
2250 if (SUCCEEDED(hrc))
2251 {
2252 for (size_t i = 0; i < coll.size(); ++i)
2253 {
2254 ComPtr<IMedium> dvdDrive = coll[i];
2255 Bstr uuid;
2256 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
2257 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2258 Bstr location;
2259 dvdDrive->COMGETTER(Location)(location.asOutParam());
2260 RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2261 }
2262 }
2263 break;
2264 }
2265
2266 case kListHostFloppies:
2267 {
2268 ComPtr<IHost> host;
2269 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2270 com::SafeIfaceArray<IMedium> coll;
2271 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
2272 if (SUCCEEDED(hrc))
2273 {
2274 for (size_t i = 0; i < coll.size(); ++i)
2275 {
2276 ComPtr<IMedium> floppyDrive = coll[i];
2277 Bstr uuid;
2278 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
2279 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2280 Bstr location;
2281 floppyDrive->COMGETTER(Location)(location.asOutParam());
2282 RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2283 }
2284 }
2285 break;
2286 }
2287
2288 case kListInternalNetworks:
2289 hrc = listInternalNetworks(pVirtualBox);
2290 break;
2291
2292 case kListBridgedInterfaces:
2293#if defined(VBOX_WITH_NETFLT)
2294 case kListHostOnlyInterfaces:
2295#endif
2296 hrc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
2297 break;
2298
2299#if defined(VBOX_WITH_VMNET)
2300 case kListHostOnlyNetworks:
2301 hrc = listHostOnlyNetworks(pVirtualBox);
2302 break;
2303#endif
2304
2305#if defined(VBOX_WITH_CLOUD_NET)
2306 case kListCloudNetworks:
2307 hrc = listCloudNetworks(pVirtualBox);
2308 break;
2309#endif
2310 case kListHostInfo:
2311 hrc = listHostInfo(pVirtualBox);
2312 break;
2313
2314 case kListHostCpuIDs:
2315 {
2316 ComPtr<IHost> Host;
2317 CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
2318 PlatformArchitecture_T platformArch;
2319 CHECK_ERROR_BREAK(Host, COMGETTER(Architecture)(&platformArch));
2320
2321 switch (platformArch)
2322 {
2323 case PlatformArchitecture_x86:
2324 {
2325 ComPtr<IHostX86> HostX86;
2326 CHECK_ERROR_BREAK(Host, COMGETTER(X86)(HostX86.asOutParam()));
2327
2328 RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n"));
2329 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
2330 static uint32_t const s_auCpuIdRanges[] =
2331 {
2332 UINT32_C(0x00000000), UINT32_C(0x0000007f),
2333 UINT32_C(0x80000000), UINT32_C(0x8000007f),
2334 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
2335 };
2336 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
2337 {
2338 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
2339 CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
2340 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
2341 continue;
2342 cLeafs++;
2343 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
2344 {
2345 CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
2346 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
2347 }
2348 }
2349
2350 break;
2351 }
2352
2353 case PlatformArchitecture_ARM:
2354 {
2355 /** @todo BUGBUG Implement this for ARM! */
2356 break;
2357 }
2358
2359 default:
2360 AssertFailed();
2361 break;
2362 }
2363 break;
2364 }
2365
2366 case kListHddBackends:
2367 hrc = listHddBackends(pVirtualBox);
2368 break;
2369
2370 case kListHdds:
2371 {
2372 com::SafeIfaceArray<IMedium> hdds;
2373 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
2374 hrc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
2375 break;
2376 }
2377
2378 case kListDvds:
2379 {
2380 com::SafeIfaceArray<IMedium> dvds;
2381 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
2382 hrc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
2383 break;
2384 }
2385
2386 case kListFloppies:
2387 {
2388 com::SafeIfaceArray<IMedium> floppies;
2389 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
2390 hrc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
2391 break;
2392 }
2393
2394 case kListUsbHost:
2395 hrc = listUsbHost(pVirtualBox);
2396 break;
2397
2398 case kListUsbFilters:
2399 hrc = listUsbFilters(pVirtualBox);
2400 break;
2401
2402 case kListSystemProperties:
2403 hrc = listSystemProperties(pVirtualBox);
2404 break;
2405
2406#ifdef VBOX_WITH_UPDATE_AGENT
2407 case kListUpdateAgents:
2408 hrc = listUpdateAgents(pVirtualBox);
2409 break;
2410#endif
2411 case kListDhcpServers:
2412 hrc = listDhcpServers(pVirtualBox);
2413 break;
2414
2415 case kListExtPacks:
2416 hrc = listExtensionPacks(pVirtualBox);
2417 break;
2418
2419 case kListGroups:
2420 hrc = listGroups(pVirtualBox);
2421 break;
2422
2423 case kListNatNetworks:
2424 hrc = listNATNetworks(fOptLong, fOptSorted, pVirtualBox);
2425 break;
2426
2427 case kListVideoInputDevices:
2428 hrc = listVideoInputDevices(pVirtualBox);
2429 break;
2430
2431 case kListScreenShotFormats:
2432 hrc = listScreenShotFormats(pVirtualBox);
2433 break;
2434
2435 case kListCloudProviders:
2436 hrc = listCloudProviders(pVirtualBox);
2437 break;
2438
2439 case kListCloudProfiles:
2440 hrc = listCloudProfiles(pVirtualBox, fOptLong);
2441 break;
2442
2443 case kListCPUProfiles:
2444 hrc = listCPUProfiles(pVirtualBox, fOptLong, fOptSorted);
2445 break;
2446
2447 case kListHostDrives:
2448 hrc = listHostDrives(pVirtualBox, fOptLong);
2449 break;
2450 /* No default here, want gcc warnings. */
2451
2452 } /* end switch */
2453
2454 return hrc;
2455}
2456
2457/**
2458 * Handles the 'list' command.
2459 *
2460 * @returns Appropriate exit code.
2461 * @param a Handler argument.
2462 */
2463RTEXITCODE handleList(HandlerArg *a)
2464{
2465 bool fOptLong = false;
2466 bool fOptMultiple = false;
2467 bool fOptSorted = false;
2468 bool fFirst = true;
2469 enum ListType_T enmOptCommand = kListNotSpecified;
2470 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2471
2472 static const RTGETOPTDEF s_aListOptions[] =
2473 {
2474 { "--long", 'l', RTGETOPT_REQ_NOTHING },
2475 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
2476 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
2477 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
2478 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
2479 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
2480 { "ossubtypes", kListOsSubtypes, RTGETOPT_REQ_NOTHING },
2481 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
2482 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
2483 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
2484 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
2485 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
2486#if defined(VBOX_WITH_NETFLT)
2487 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
2488#endif
2489#if defined(VBOX_WITH_VMNET)
2490 { "hostonlynets", kListHostOnlyNetworks, RTGETOPT_REQ_NOTHING },
2491#endif
2492#if defined(VBOX_WITH_CLOUD_NET)
2493 { "cloudnets", kListCloudNetworks, RTGETOPT_REQ_NOTHING },
2494#endif
2495 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2496 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2497 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
2498 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
2499 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
2500 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
2501 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
2502 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
2503 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
2504 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
2505 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
2506#if defined(VBOX_WITH_UPDATE_AGENT)
2507 { "updates", kListUpdateAgents, RTGETOPT_REQ_NOTHING },
2508#endif
2509 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
2510 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
2511 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
2512 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
2513 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
2514 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
2515 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
2516 { "cpu-profiles", kListCPUProfiles, RTGETOPT_REQ_NOTHING },
2517 { "hostdrives", kListHostDrives, RTGETOPT_REQ_NOTHING },
2518 };
2519
2520 int ch;
2521 RTGETOPTUNION ValueUnion;
2522 RTGETOPTSTATE GetState;
2523 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
2524 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
2525 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2526 {
2527 switch (ch)
2528 {
2529 case 'l': /* --long */
2530 fOptLong = true;
2531 break;
2532
2533 case 's':
2534 fOptSorted = true;
2535 break;
2536
2537 case 'm':
2538 fOptMultiple = true;
2539 if (enmOptCommand == kListNotSpecified)
2540 break;
2541 ch = enmOptCommand;
2542 RT_FALL_THRU();
2543
2544 case kListVMs:
2545 case kListRunningVMs:
2546 case kListOsTypes:
2547 case kListOsSubtypes:
2548 case kListHostDvds:
2549 case kListHostFloppies:
2550 case kListInternalNetworks:
2551 case kListBridgedInterfaces:
2552#if defined(VBOX_WITH_NETFLT)
2553 case kListHostOnlyInterfaces:
2554#endif
2555#if defined(VBOX_WITH_VMNET)
2556 case kListHostOnlyNetworks:
2557#endif
2558#if defined(VBOX_WITH_CLOUD_NET)
2559 case kListCloudNetworks:
2560#endif
2561 case kListHostInfo:
2562 case kListHostCpuIDs:
2563 case kListHddBackends:
2564 case kListHdds:
2565 case kListDvds:
2566 case kListFloppies:
2567 case kListUsbHost:
2568 case kListUsbFilters:
2569 case kListSystemProperties:
2570#if defined(VBOX_WITH_UPDATE_AGENT)
2571 case kListUpdateAgents:
2572#endif
2573 case kListDhcpServers:
2574 case kListExtPacks:
2575 case kListGroups:
2576 case kListNatNetworks:
2577 case kListVideoInputDevices:
2578 case kListScreenShotFormats:
2579 case kListCloudProviders:
2580 case kListCloudProfiles:
2581 case kListCPUProfiles:
2582 case kListHostDrives:
2583 enmOptCommand = (enum ListType_T)ch;
2584 if (fOptMultiple)
2585 {
2586 if (fFirst)
2587 fFirst = false;
2588 else
2589 RTPrintf("\n");
2590 RTPrintf("[%s]\n", ValueUnion.pDef->pszLong);
2591 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2592 if (FAILED(hrc))
2593 rcExit = RTEXITCODE_FAILURE;
2594 }
2595 break;
2596
2597 case VINF_GETOPT_NOT_OPTION:
2598 return errorSyntax(List::tr("Unknown subcommand \"%s\"."), ValueUnion.psz);
2599
2600 default:
2601 return errorGetOpt(ch, &ValueUnion);
2602 }
2603 }
2604
2605 /*
2606 * If not in multiple list mode, we have to produce the list now.
2607 */
2608 if (enmOptCommand == kListNotSpecified)
2609 return errorSyntax(List::tr("Missing subcommand for \"list\" command.\n"));
2610 if (!fOptMultiple)
2611 {
2612 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2613 if (FAILED(hrc))
2614 rcExit = RTEXITCODE_FAILURE;
2615 }
2616
2617 return rcExit;
2618}
2619
2620/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

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