VirtualBox

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

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

Frontends/VBoxManage,Main/VirtualBox: Change the newly added IVirtualBox
method getGuestOSFamilies() to be an attribute instead as there are no
"in" arguments passed to this function. bugref:5936
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 105.4 KB
Line 
1/* $Id: VBoxManageList.cpp 101180 2023-09-19 17:18:37Z 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
798static HRESULT listPlatformProperties(const ComPtr<IPlatformProperties> &platformProperties)
799{
800 ULONG ulValue;
801 platformProperties->COMGETTER(SerialPortCount)(&ulValue);
802 RTPrintf(List::tr("Maximum Serial Port count: %u\n"), ulValue);
803 platformProperties->COMGETTER(ParallelPortCount)(&ulValue);
804 RTPrintf(List::tr("Maximum Parallel Port count: %u\n"), ulValue);
805 platformProperties->COMGETTER(MaxBootPosition)(&ulValue);
806 RTPrintf(List::tr("Maximum Boot Position: %u\n"), ulValue);
807 platformProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
808 RTPrintf(List::tr("Maximum Floppy Port count: %u\n"), ulValue);
809 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
810 RTPrintf(List::tr("Maximum Floppy Devices per Port: %u\n"), ulValue);
811 platformProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
812 RTPrintf(List::tr("Maximum virtio-scsi Port count: %u\n"), ulValue);
813 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
814 RTPrintf(List::tr("Maximum virtio-scsi Devices per Port: %u\n"), ulValue);
815 platformProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
816 RTPrintf(List::tr("Maximum IDE Port count: %u\n"), ulValue);
817 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
818 RTPrintf(List::tr("Maximum IDE Devices per port: %u\n"), ulValue);
819 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
820 RTPrintf(List::tr("Maximum SATA Port count: %u\n"), ulValue);
821 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
822 RTPrintf(List::tr("Maximum SATA Device per port: %u\n"), ulValue);
823 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
824 RTPrintf(List::tr("Maximum SCSI Port count: %u\n"), ulValue);
825 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
826 RTPrintf(List::tr("Maximum SCSI Devices per port: %u\n"), ulValue);
827 platformProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
828 RTPrintf(List::tr("Maximum SAS Port count: %u\n"), ulValue);
829 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
830 RTPrintf(List::tr("Maximum SAS Devices per Port: %u\n"), ulValue);
831 platformProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
832 RTPrintf(List::tr("Maximum NVMe Port count: %u\n"), ulValue);
833 platformProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
834 RTPrintf(List::tr("Maximum NVMe Devices per Port: %u\n"), ulValue);
835
836 SafeArray <ChipsetType_T> saChipset;
837 platformProperties->COMGETTER(SupportedChipsetTypes(ComSafeArrayAsOutParam(saChipset)));
838
839 RTPrintf(List::tr("Supported chipsets: "));
840 for (size_t i = 0; i < saChipset.size(); i++)
841 {
842 if (i > 0)
843 RTPrintf(", ");
844 RTPrintf("%s", chipsetTypeToStr(saChipset[i]));
845 }
846 RTPrintf("\n");
847
848 for (size_t i = 0; i < saChipset.size(); i++)
849 {
850 if (i > 0)
851 RTPrintf("\n");
852 RTPrintf(List::tr("%s chipset properties:\n"), chipsetTypeToStr(saChipset[i]));
853 listPlatformChipsetProperties(platformProperties, saChipset[i]);
854 }
855
856 return S_OK;
857}
858
859/**
860 * List system properties.
861 *
862 * @returns See produceList.
863 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
864 */
865static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox)
866{
867 ComPtr<ISystemProperties> systemProperties;
868 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
869
870 ComPtr<IPlatformProperties> hostPlatformProperties;
871 CHECK_ERROR2I_RET(systemProperties, COMGETTER(Platform)(hostPlatformProperties.asOutParam()), hrcCheck);
872
873 Bstr str;
874 ULONG ulValue;
875 LONG64 i64Value;
876 BOOL fValue;
877 const char *psz;
878
879 pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
880 RTPrintf(List::tr("API version: %ls\n"), str.raw());
881
882 systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
883 RTPrintf(List::tr("Minimum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
884 systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
885 RTPrintf(List::tr("Maximum guest RAM size: %u Megabytes\n", "", ulValue), ulValue);
886 systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
887 RTPrintf(List::tr("Minimum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
888 systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
889 RTPrintf(List::tr("Maximum video RAM size: %u Megabytes\n", "", ulValue), ulValue);
890 systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
891 RTPrintf(List::tr("Maximum guest monitor count: %u\n"), ulValue);
892 systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
893 RTPrintf(List::tr("Minimum guest CPU count: %u\n"), ulValue);
894 systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
895 RTPrintf(List::tr("Maximum guest CPU count: %u\n"), ulValue);
896 systemProperties->COMGETTER(InfoVDSize)(&i64Value);
897 RTPrintf(List::tr("Virtual disk limit (info): %lld Bytes\n", "" , i64Value), i64Value);
898
899#if 0
900 systemProperties->GetFreeDiskSpaceWarning(&i64Value);
901 RTPrintf(List::tr("Free disk space warning at: %u Bytes\n", "", i64Value), i64Value);
902 systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
903 RTPrintf(List::tr("Free disk space warning at: %u %%\n"), ulValue);
904 systemProperties->GetFreeDiskSpaceError(&i64Value);
905 RTPrintf(List::tr("Free disk space error at: %u Bytes\n", "", i64Value), i64Value);
906 systemProperties->GetFreeDiskSpacePercentError(&ulValue);
907 RTPrintf(List::tr("Free disk space error at: %u %%\n"), ulValue);
908#endif
909 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
910 RTPrintf(List::tr("Default machine folder: %ls\n"), str.raw());
911 hostPlatformProperties->COMGETTER(RawModeSupported)(&fValue);
912 RTPrintf(List::tr("Raw-mode Supported: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
913 hostPlatformProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
914 RTPrintf(List::tr("Exclusive HW virtualization use: %s\n"), fValue ? List::tr("on") : List::tr("off"));
915 systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
916 RTPrintf(List::tr("Default hard disk format: %ls\n"), str.raw());
917 systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
918 RTPrintf(List::tr("VRDE auth library: %ls\n"), str.raw());
919 systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
920 RTPrintf(List::tr("Webservice auth. library: %ls\n"), str.raw());
921 systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
922 RTPrintf(List::tr("Remote desktop ExtPack: %ls\n"), str.raw());
923 systemProperties->COMGETTER(DefaultCryptoExtPack)(str.asOutParam());
924 RTPrintf(List::tr("VM encryption ExtPack: %ls\n"), str.raw());
925 systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
926 RTPrintf(List::tr("Log history count: %u\n"), ulValue);
927 systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
928 RTPrintf(List::tr("Default frontend: %ls\n"), str.raw());
929 AudioDriverType_T enmAudio;
930 systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
931 switch (enmAudio)
932 {
933 case AudioDriverType_Default: psz = List::tr("Default"); break;
934 case AudioDriverType_Null: psz = List::tr("Null"); break;
935 case AudioDriverType_OSS: psz = "OSS"; break;
936 case AudioDriverType_ALSA: psz = "ALSA"; break;
937 case AudioDriverType_Pulse: psz = "PulseAudio"; break;
938 case AudioDriverType_WinMM: psz = "WinMM"; break;
939 case AudioDriverType_DirectSound: psz = "DirectSound"; break;
940 case AudioDriverType_WAS: psz = "Windows Audio Session"; break;
941 case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
942 case AudioDriverType_SolAudio: psz = "SolAudio"; break;
943 case AudioDriverType_MMPM: psz = "MMPM"; break;
944 default: psz = List::tr("Unknown");
945 }
946 RTPrintf(List::tr("Default audio driver: %s\n"), psz);
947 systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
948 RTPrintf(List::tr("Autostart database path: %ls\n"), str.raw());
949 systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
950 RTPrintf(List::tr("Default Guest Additions ISO: %ls\n"), str.raw());
951 systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
952 RTPrintf(List::tr("Logging Level: %ls\n"), str.raw());
953 ProxyMode_T enmProxyMode = (ProxyMode_T)42;
954 systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
955 psz = List::tr("Unknown");
956 switch (enmProxyMode)
957 {
958 case ProxyMode_System: psz = List::tr("System"); break;
959 case ProxyMode_NoProxy: psz = List::tr("NoProxy"); break;
960 case ProxyMode_Manual: psz = List::tr("Manual"); break;
961#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
962 case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */
963#endif
964 }
965 RTPrintf(List::tr("Proxy Mode: %s\n"), psz);
966 systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
967 RTPrintf(List::tr("Proxy URL: %ls\n"), str.raw());
968#ifdef VBOX_WITH_MAIN_NLS
969 systemProperties->COMGETTER(LanguageId)(str.asOutParam());
970 RTPrintf(List::tr("User language: %ls\n"), str.raw());
971#endif
972
973 RTPrintf("Host platform properties:\n");
974 listPlatformProperties(hostPlatformProperties);
975
976 /* Separate host system / platform properties stuff from guest platform properties a bit. */
977 RTPrintf("\n");
978
979 SafeArray <PlatformArchitecture_T> saPlatformArch;
980 systemProperties->COMGETTER(SupportedPlatformArchitectures(ComSafeArrayAsOutParam(saPlatformArch)));
981 RTPrintf("Supported platform architectures: ");
982 for (size_t i = 0; i < saPlatformArch.size(); ++i)
983 {
984 if (i > 0)
985 RTPrintf(",");
986 RTPrintf(platformArchitectureToStr(saPlatformArch[i]));
987 }
988 RTPrintf("\n\n");
989
990 for (size_t i = 0; i < saPlatformArch.size(); ++i)
991 {
992 if (i > 0)
993 RTPrintf("\n");
994 ComPtr<IPlatformProperties> platformProperties;
995 pVirtualBox->GetPlatformProperties(saPlatformArch[i], platformProperties.asOutParam());
996 RTPrintf(List::tr("%s platform properties:\n"), platformArchitectureToStr(saPlatformArch[i]));
997 listPlatformProperties(platformProperties);
998 }
999
1000 return S_OK;
1001}
1002
1003#ifdef VBOX_WITH_UPDATE_AGENT
1004static HRESULT listUpdateAgentConfig(ComPtr<IUpdateAgent> ptrUpdateAgent)
1005{
1006 BOOL fValue;
1007 ptrUpdateAgent->COMGETTER(Enabled)(&fValue);
1008 RTPrintf(List::tr("Enabled: %s\n"), fValue ? List::tr("yes") : List::tr("no"));
1009 ULONG ulValue;
1010 ptrUpdateAgent->COMGETTER(CheckCount)(&ulValue);
1011 RTPrintf(List::tr("Check count: %u\n"), ulValue);
1012 ptrUpdateAgent->COMGETTER(CheckFrequency)(&ulValue);
1013 if (ulValue == 0)
1014 RTPrintf(List::tr("Check frequency: never\n"));
1015 else if (ulValue == 1)
1016 RTPrintf(List::tr("Check frequency: every day\n"));
1017 else
1018 RTPrintf(List::tr("Check frequency: every %u days\n", "", ulValue), ulValue);
1019
1020 Bstr str;
1021 const char *psz;
1022 UpdateChannel_T enmUpdateChannel;
1023 ptrUpdateAgent->COMGETTER(Channel)(&enmUpdateChannel);
1024 switch (enmUpdateChannel)
1025 {
1026 case UpdateChannel_Stable:
1027 psz = List::tr("Stable: Maintenance and minor releases within the same major release");
1028 break;
1029 case UpdateChannel_All:
1030 psz = List::tr("All releases: All stable releases, including major versions");
1031 break;
1032 case UpdateChannel_WithBetas:
1033 psz = List::tr("With Betas: All stable and major releases, including beta versions");
1034 break;
1035 case UpdateChannel_WithTesting:
1036 psz = List::tr("With Testing: All stable, major and beta releases, including testing versions");
1037 break;
1038 default:
1039 psz = List::tr("Unset");
1040 break;
1041 }
1042 RTPrintf(List::tr("Channel: %s\n"), psz);
1043 ptrUpdateAgent->COMGETTER(RepositoryURL)(str.asOutParam());
1044 RTPrintf(List::tr("Repository: %ls\n"), str.raw());
1045 ptrUpdateAgent->COMGETTER(LastCheckDate)(str.asOutParam());
1046 RTPrintf(List::tr("Last check date: %ls\n"), str.raw());
1047
1048 return S_OK;
1049}
1050
1051static HRESULT listUpdateAgents(const ComPtr<IVirtualBox> &pVirtualBox)
1052{
1053 ComPtr<IHost> pHost;
1054 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), RTEXITCODE_FAILURE);
1055
1056 ComPtr<IUpdateAgent> pUpdateHost;
1057 CHECK_ERROR2I_RET(pHost, COMGETTER(UpdateHost)(pUpdateHost.asOutParam()), RTEXITCODE_FAILURE);
1058 /** @todo Add other update agents here. */
1059
1060 return listUpdateAgentConfig(pUpdateHost);
1061}
1062#endif /* VBOX_WITH_UPDATE_AGENT */
1063
1064/**
1065 * Helper for listDhcpServers() that shows a DHCP configuration.
1066 */
1067static HRESULT showDhcpConfig(ComPtr<IDHCPConfig> ptrConfig)
1068{
1069 HRESULT hrcRet = S_OK;
1070
1071 ULONG secs = 0;
1072 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MinLeaseTime)(&secs), hrcRet = hrcCheck);
1073 if (secs == 0)
1074 RTPrintf(List::tr(" minLeaseTime: default\n"));
1075 else
1076 RTPrintf(List::tr(" minLeaseTime: %u sec\n"), secs);
1077
1078 secs = 0;
1079 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(DefaultLeaseTime)(&secs), hrcRet = hrcCheck);
1080 if (secs == 0)
1081 RTPrintf(List::tr(" defaultLeaseTime: default\n"));
1082 else
1083 RTPrintf(List::tr(" defaultLeaseTime: %u sec\n"), secs);
1084
1085 secs = 0;
1086 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MaxLeaseTime)(&secs), hrcRet = hrcCheck);
1087 if (secs == 0)
1088 RTPrintf(List::tr(" maxLeaseTime: default\n"));
1089 else
1090 RTPrintf(List::tr(" maxLeaseTime: %u sec\n"), secs);
1091
1092 com::SafeArray<DHCPOption_T> Options;
1093 HRESULT hrc;
1094 CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(ForcedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1095 if (FAILED(hrc))
1096 RTPrintf(List::tr(" Forced options: %Rhrc\n"), hrc);
1097 else if (Options.size() == 0)
1098 RTPrintf(List::tr(" Forced options: None\n"));
1099 else
1100 {
1101 RTPrintf(List::tr(" Forced options: "));
1102 for (size_t i = 0; i < Options.size(); i++)
1103 RTPrintf(i ? ", %u" : "%u", Options[i]);
1104 RTPrintf("\n");
1105 }
1106
1107 CHECK_ERROR2_STMT(hrc, ptrConfig, COMGETTER(SuppressedOptions(ComSafeArrayAsOutParam(Options))), hrcRet = hrc);
1108 if (FAILED(hrc))
1109 RTPrintf(List::tr(" Suppressed opt.s: %Rhrc\n"), hrc);
1110 else if (Options.size() == 0)
1111 RTPrintf(List::tr(" Suppressed opts.: None\n"));
1112 else
1113 {
1114 RTPrintf(List::tr(" Suppressed opts.: "));
1115 for (size_t i = 0; i < Options.size(); i++)
1116 RTPrintf(i ? ", %u" : "%u", Options[i]);
1117 RTPrintf("\n");
1118 }
1119
1120 com::SafeArray<DHCPOptionEncoding_T> Encodings;
1121 com::SafeArray<BSTR> Values;
1122 CHECK_ERROR2_STMT(hrc, ptrConfig, GetAllOptions(ComSafeArrayAsOutParam(Options),
1123 ComSafeArrayAsOutParam(Encodings),
1124 ComSafeArrayAsOutParam(Values)), hrcRet = hrc);
1125 if (FAILED(hrc))
1126 RTPrintf(List::tr(" DHCP options: %Rhrc\n"), hrc);
1127 else if (Options.size() != Encodings.size() || Options.size() != Values.size())
1128 {
1129 RTPrintf(List::tr(" DHCP options: Return count mismatch: %zu, %zu, %zu\n"),
1130 Options.size(), Encodings.size(), Values.size());
1131 hrcRet = E_FAIL;
1132 }
1133 else if (Options.size() == 0)
1134 RTPrintf(List::tr(" DHCP options: None\n"));
1135 else
1136 for (size_t i = 0; i < Options.size(); i++)
1137 {
1138 switch (Encodings[i])
1139 {
1140 case DHCPOptionEncoding_Normal:
1141 RTPrintf(List::tr(" %3d/legacy: %ls\n"), Options[i], Values[i]);
1142 break;
1143 case DHCPOptionEncoding_Hex:
1144 RTPrintf(" %3d/hex: %ls\n", Options[i], Values[i]);
1145 break;
1146 default:
1147 RTPrintf(" %3d/%u?: %ls\n", Options[i], Encodings[i], Values[i]);
1148 break;
1149 }
1150 }
1151
1152 return S_OK;
1153}
1154
1155
1156/**
1157 * List DHCP servers.
1158 *
1159 * @returns See produceList.
1160 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1161 */
1162static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox)
1163{
1164 HRESULT hrcRet = S_OK;
1165 com::SafeIfaceArray<IDHCPServer> DHCPServers;
1166 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(DHCPServers)), hrcCheck);
1167 for (size_t i = 0; i < DHCPServers.size(); ++i)
1168 {
1169 if (i > 0)
1170 RTPrintf("\n");
1171
1172 ComPtr<IDHCPServer> ptrDHCPServer = DHCPServers[i];
1173 Bstr bstr;
1174 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkName)(bstr.asOutParam()), hrcRet = hrcCheck);
1175 RTPrintf(List::tr("NetworkName: %ls\n"), bstr.raw());
1176
1177 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(IPAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1178 RTPrintf("Dhcpd IP: %ls\n", bstr.raw());
1179
1180 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(LowerIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1181 RTPrintf(List::tr("LowerIPAddress: %ls\n"), bstr.raw());
1182
1183 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(UpperIP)(bstr.asOutParam()), hrcRet = hrcCheck);
1184 RTPrintf(List::tr("UpperIPAddress: %ls\n"), bstr.raw());
1185
1186 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(NetworkMask)(bstr.asOutParam()), hrcRet = hrcCheck);
1187 RTPrintf(List::tr("NetworkMask: %ls\n"), bstr.raw());
1188
1189 BOOL fEnabled = FALSE;
1190 CHECK_ERROR2I_STMT(ptrDHCPServer, COMGETTER(Enabled)(&fEnabled), hrcRet = hrcCheck);
1191 RTPrintf(List::tr("Enabled: %s\n"), fEnabled ? List::tr("Yes") : List::tr("No"));
1192
1193 /* Global configuration: */
1194 RTPrintf(List::tr("Global Configuration:\n"));
1195 HRESULT hrc;
1196 ComPtr<IDHCPGlobalConfig> ptrGlobal;
1197 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GlobalConfig)(ptrGlobal.asOutParam()), hrcRet = hrc);
1198 if (SUCCEEDED(hrc))
1199 {
1200 hrc = showDhcpConfig(ptrGlobal);
1201 if (FAILED(hrc))
1202 hrcRet = hrc;
1203 }
1204
1205 /* Group configurations: */
1206 com::SafeIfaceArray<IDHCPGroupConfig> Groups;
1207 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(GroupConfigs)(ComSafeArrayAsOutParam(Groups)), hrcRet = hrc);
1208 if (FAILED(hrc))
1209 RTPrintf(List::tr("Groups: %Rrc\n"), hrc);
1210 else if (Groups.size() == 0)
1211 RTPrintf(List::tr("Groups: None\n"));
1212 else
1213 {
1214 for (size_t iGrp = 0; iGrp < Groups.size(); iGrp++)
1215 {
1216 CHECK_ERROR2I_STMT(Groups[iGrp], COMGETTER(Name)(bstr.asOutParam()), hrcRet = hrcCheck);
1217 RTPrintf(List::tr("Group: %ls\n"), bstr.raw());
1218
1219 com::SafeIfaceArray<IDHCPGroupCondition> Conditions;
1220 CHECK_ERROR2_STMT(hrc, Groups[iGrp], COMGETTER(Conditions)(ComSafeArrayAsOutParam(Conditions)), hrcRet = hrc);
1221 if (FAILED(hrc))
1222 RTPrintf(List::tr(" Conditions: %Rhrc\n"), hrc);
1223 else if (Conditions.size() == 0)
1224 RTPrintf(List::tr(" Conditions: None\n"));
1225 else
1226 for (size_t iCond = 0; iCond < Conditions.size(); iCond++)
1227 {
1228 BOOL fInclusive = TRUE;
1229 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Inclusive)(&fInclusive), hrcRet = hrc);
1230 DHCPGroupConditionType_T enmType = DHCPGroupConditionType_MAC;
1231 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Type)(&enmType), hrcRet = hrc);
1232 CHECK_ERROR2_STMT(hrc, Conditions[iCond], COMGETTER(Value)(bstr.asOutParam()), hrcRet = hrc);
1233
1234 RTPrintf(List::tr(" Conditions: %s %s %ls\n"),
1235 fInclusive ? List::tr("include") : List::tr("exclude"),
1236 enmType == DHCPGroupConditionType_MAC ? "MAC "
1237 : enmType == DHCPGroupConditionType_MACWildcard ? "MAC* "
1238 : enmType == DHCPGroupConditionType_vendorClassID ? "VendorCID "
1239 : enmType == DHCPGroupConditionType_vendorClassIDWildcard ? "VendorCID*"
1240 : enmType == DHCPGroupConditionType_userClassID ? "UserCID "
1241 : enmType == DHCPGroupConditionType_userClassIDWildcard ? "UserCID* "
1242 : "!UNKNOWN! ",
1243 bstr.raw());
1244 }
1245
1246 hrc = showDhcpConfig(Groups[iGrp]);
1247 if (FAILED(hrc))
1248 hrcRet = hrc;
1249 }
1250 Groups.setNull();
1251 }
1252
1253 /* Individual host / NIC configurations: */
1254 com::SafeIfaceArray<IDHCPIndividualConfig> Hosts;
1255 CHECK_ERROR2_STMT(hrc, ptrDHCPServer, COMGETTER(IndividualConfigs)(ComSafeArrayAsOutParam(Hosts)), hrcRet = hrc);
1256 if (FAILED(hrc))
1257 RTPrintf(List::tr("Individual Configs: %Rrc\n"), hrc);
1258 else if (Hosts.size() == 0)
1259 RTPrintf(List::tr("Individual Configs: None\n"));
1260 else
1261 {
1262 for (size_t iHost = 0; iHost < Hosts.size(); iHost++)
1263 {
1264 DHCPConfigScope_T enmScope = DHCPConfigScope_MAC;
1265 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Scope)(&enmScope), hrcRet = hrcCheck);
1266
1267 if (enmScope == DHCPConfigScope_MAC)
1268 {
1269 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MACAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1270 RTPrintf(List::tr("Individual Config: MAC %ls\n"), bstr.raw());
1271 }
1272 else
1273 {
1274 ULONG uSlot = 0;
1275 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Slot)(&uSlot), hrcRet = hrcCheck);
1276 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(MachineId)(bstr.asOutParam()), hrcRet = hrcCheck);
1277 Bstr bstrMACAddress;
1278 hrc = Hosts[iHost]->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); /* No CHECK_ERROR2 stuff! */
1279 if (SUCCEEDED(hrc))
1280 RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %ls\n"), bstr.raw(), uSlot,
1281 bstrMACAddress.raw());
1282 else
1283 RTPrintf(List::tr("Individual Config: VM NIC: %ls slot %u, MAC %Rhrc\n"), bstr.raw(), uSlot, hrc);
1284 }
1285
1286 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(FixedAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
1287 if (bstr.isNotEmpty())
1288 RTPrintf(List::tr(" Fixed Address: %ls\n"), bstr.raw());
1289 else
1290 RTPrintf(List::tr(" Fixed Address: dynamic\n"));
1291
1292 hrc = showDhcpConfig(Hosts[iHost]);
1293 if (FAILED(hrc))
1294 hrcRet = hrc;
1295 }
1296 Hosts.setNull();
1297 }
1298 }
1299
1300 return hrcRet;
1301}
1302
1303/**
1304 * List extension packs.
1305 *
1306 * @returns See produceList.
1307 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1308 */
1309static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
1310{
1311 ComObjPtr<IExtPackManager> ptrExtPackMgr;
1312 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
1313
1314 SafeIfaceArray<IExtPack> extPacks;
1315 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
1316 RTPrintf(List::tr("Extension Packs: %u\n"), extPacks.size());
1317
1318 HRESULT hrc = S_OK;
1319 for (size_t i = 0; i < extPacks.size(); i++)
1320 {
1321 /* Read all the properties. */
1322 Bstr bstrName;
1323 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
1324 Bstr bstrDesc;
1325 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
1326 Bstr bstrVersion;
1327 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
1328 ULONG uRevision;
1329 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
1330 Bstr bstrEdition;
1331 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
1332 Bstr bstrVrdeModule;
1333 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
1334 Bstr bstrCryptoModule;
1335 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(CryptoModule)(bstrCryptoModule.asOutParam()),hrc=hrcCheck; bstrCryptoModule.setNull());
1336 BOOL fUsable;
1337 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
1338 Bstr bstrWhy;
1339 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
1340
1341 /* Display them. */
1342 if (i)
1343 RTPrintf("\n");
1344 RTPrintf(List::tr(
1345 "Pack no.%2zu: %ls\n"
1346 "Version: %ls\n"
1347 "Revision: %u\n"
1348 "Edition: %ls\n"
1349 "Description: %ls\n"
1350 "VRDE Module: %ls\n"
1351 "Crypto Module: %ls\n"
1352 "Usable: %RTbool\n"
1353 "Why unusable: %ls\n"),
1354 i, bstrName.raw(),
1355 bstrVersion.raw(),
1356 uRevision,
1357 bstrEdition.raw(),
1358 bstrDesc.raw(),
1359 bstrVrdeModule.raw(),
1360 bstrCryptoModule.raw(),
1361 fUsable != FALSE,
1362 bstrWhy.raw());
1363
1364 /* Query plugins and display them. */
1365 }
1366 return hrc;
1367}
1368
1369
1370/**
1371 * List machine groups.
1372 *
1373 * @returns See produceList.
1374 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1375 */
1376static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
1377{
1378 SafeArray<BSTR> groups;
1379 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
1380
1381 for (size_t i = 0; i < groups.size(); i++)
1382 {
1383 RTPrintf("\"%ls\"\n", groups[i]);
1384 }
1385 return S_OK;
1386}
1387
1388
1389/**
1390 * List video capture devices.
1391 *
1392 * @returns See produceList.
1393 * @param pVirtualBox Reference to the IVirtualBox pointer.
1394 */
1395static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> &pVirtualBox)
1396{
1397 HRESULT hrc;
1398 ComPtr<IHost> host;
1399 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1400 com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
1401 CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
1402 RTPrintf(List::tr("Video Input Devices: %u\n"), hostVideoInputDevices.size());
1403 for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
1404 {
1405 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
1406 Bstr name;
1407 p->COMGETTER(Name)(name.asOutParam());
1408 Bstr path;
1409 p->COMGETTER(Path)(path.asOutParam());
1410 Bstr alias;
1411 p->COMGETTER(Alias)(alias.asOutParam());
1412 RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
1413 }
1414 return hrc;
1415}
1416
1417/**
1418 * List supported screen shot formats.
1419 *
1420 * @returns See produceList.
1421 * @param pVirtualBox Reference to the IVirtualBox pointer.
1422 */
1423static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> &pVirtualBox)
1424{
1425 HRESULT hrc = S_OK;
1426 ComPtr<ISystemProperties> systemProperties;
1427 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
1428 com::SafeArray<BitmapFormat_T> formats;
1429 CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
1430
1431 RTPrintf(List::tr("Supported %d screen shot formats:\n", "", formats.size()), formats.size());
1432 for (size_t i = 0; i < formats.size(); ++i)
1433 {
1434 uint32_t u32Format = (uint32_t)formats[i];
1435 char szFormat[5];
1436 szFormat[0] = RT_BYTE1(u32Format);
1437 szFormat[1] = RT_BYTE2(u32Format);
1438 szFormat[2] = RT_BYTE3(u32Format);
1439 szFormat[3] = RT_BYTE4(u32Format);
1440 szFormat[4] = 0;
1441 RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
1442 }
1443 return hrc;
1444}
1445
1446/**
1447 * List available cloud providers.
1448 *
1449 * @returns See produceList.
1450 * @param pVirtualBox Reference to the IVirtualBox pointer.
1451 */
1452static HRESULT listCloudProviders(const ComPtr<IVirtualBox> &pVirtualBox)
1453{
1454 HRESULT hrc = S_OK;
1455 ComPtr<ICloudProviderManager> pCloudProviderManager;
1456 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1457 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1458 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1459
1460 RTPrintf(List::tr("Supported %d cloud providers:\n", "", apCloudProviders.size()), apCloudProviders.size());
1461 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1462 {
1463 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1464 Bstr bstrProviderName;
1465 pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
1466 RTPrintf(List::tr("Name: %ls\n"), bstrProviderName.raw());
1467 pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
1468 RTPrintf(List::tr("Short Name: %ls\n"), bstrProviderName.raw());
1469 Bstr bstrProviderID;
1470 pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
1471 RTPrintf("GUID: %ls\n", bstrProviderID.raw());
1472
1473 RTPrintf("\n");
1474 }
1475 return hrc;
1476}
1477
1478
1479/**
1480 * List all available cloud profiles (by iterating over the cloud providers).
1481 *
1482 * @returns See produceList.
1483 * @param pVirtualBox Reference to the IVirtualBox pointer.
1484 * @param fOptLong If true, list all profile properties.
1485 */
1486static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> &pVirtualBox, bool fOptLong)
1487{
1488 HRESULT hrc = S_OK;
1489 ComPtr<ICloudProviderManager> pCloudProviderManager;
1490 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1491 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1492 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1493
1494 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1495 {
1496 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1497 com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
1498 CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
1499 for (size_t j = 0; j < apCloudProfiles.size(); ++j)
1500 {
1501 ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
1502 Bstr bstrProfileName;
1503 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
1504 RTPrintf(List::tr("Name: %ls\n"), bstrProfileName.raw());
1505 Bstr bstrProviderID;
1506 pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
1507 RTPrintf(List::tr("Provider GUID: %ls\n"), bstrProviderID.raw());
1508
1509 if (fOptLong)
1510 {
1511 com::SafeArray<BSTR> names;
1512 com::SafeArray<BSTR> values;
1513 pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1514 size_t cNames = names.size();
1515 size_t cValues = values.size();
1516 bool fFirst = true;
1517 for (size_t k = 0; k < cNames; k++)
1518 {
1519 Bstr value;
1520 if (k < cValues)
1521 value = values[k];
1522 RTPrintf("%s%ls=%ls\n",
1523 fFirst ? List::tr("Property: ") : " ",
1524 names[k], value.raw());
1525 fFirst = false;
1526 }
1527 }
1528
1529 RTPrintf("\n");
1530 }
1531 }
1532 return hrc;
1533}
1534
1535static HRESULT displayCPUProfile(ICPUProfile *pProfile, size_t idx, int cchIdx, bool fOptLong, HRESULT hrc)
1536{
1537 /* Retrieve the attributes needed for both long and short display. */
1538 Bstr bstrName;
1539 CHECK_ERROR2I_RET(pProfile, COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1540
1541 CPUArchitecture_T enmArchitecture = CPUArchitecture_Any;
1542 CHECK_ERROR2I_RET(pProfile, COMGETTER(Architecture)(&enmArchitecture), hrcCheck);
1543 const char *pszArchitecture = "???";
1544 switch (enmArchitecture)
1545 {
1546 case CPUArchitecture_x86: pszArchitecture = "x86"; break;
1547 case CPUArchitecture_AMD64: pszArchitecture = "AMD64"; break;
1548 case CPUArchitecture_ARMv8_32: pszArchitecture = "ARMv8 (32-bit only)"; break;
1549 case CPUArchitecture_ARMv8_64: pszArchitecture = "ARMv8 (64-bit)"; break;
1550#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1551 case CPUArchitecture_32BitHack:
1552#endif
1553 case CPUArchitecture_Any:
1554 break;
1555 }
1556
1557 /* Print what we've got. */
1558 if (!fOptLong)
1559 RTPrintf("#%0*zu: %ls [%s]\n", cchIdx, idx, bstrName.raw(), pszArchitecture);
1560 else
1561 {
1562 RTPrintf(List::tr("CPU Profile #%02zu:\n"), idx);
1563 RTPrintf(List::tr(" Architecture: %s\n"), pszArchitecture);
1564 RTPrintf(List::tr(" Name: %ls\n"), bstrName.raw());
1565 CHECK_ERROR2I_RET(pProfile, COMGETTER(FullName)(bstrName.asOutParam()), hrcCheck);
1566 RTPrintf(List::tr(" Full Name: %ls\n"), bstrName.raw());
1567 }
1568 return hrc;
1569}
1570
1571
1572/**
1573 * List all CPU profiles.
1574 *
1575 * @returns See produceList.
1576 * @param ptrVirtualBox Reference to the smart IVirtualBox pointer.
1577 * @param fOptLong If true, list all profile properties.
1578 * @param fOptSorted Sort the output if true, otherwise display in
1579 * system order.
1580 */
1581static HRESULT listCPUProfiles(const ComPtr<IVirtualBox> &ptrVirtualBox, bool fOptLong, bool fOptSorted)
1582{
1583 ComPtr<ISystemProperties> ptrSysProps;
1584 CHECK_ERROR2I_RET(ptrVirtualBox, COMGETTER(SystemProperties)(ptrSysProps.asOutParam()), hrcCheck);
1585 com::SafeIfaceArray<ICPUProfile> aCPUProfiles;
1586 CHECK_ERROR2I_RET(ptrSysProps, GetCPUProfiles(CPUArchitecture_Any, Bstr().raw(),
1587 ComSafeArrayAsOutParam(aCPUProfiles)), hrcCheck);
1588
1589 int const cchIdx = 1 + (aCPUProfiles.size() >= 10) + (aCPUProfiles.size() >= 100);
1590
1591 HRESULT hrc = S_OK;
1592 if (!fOptSorted)
1593 for (size_t i = 0; i < aCPUProfiles.size(); i++)
1594 hrc = displayCPUProfile(aCPUProfiles[i], i, cchIdx, fOptLong, hrc);
1595 else
1596 {
1597 std::vector<std::pair<com::Bstr, ICPUProfile *> > vecSortedProfiles;
1598 for (size_t i = 0; i < aCPUProfiles.size(); ++i)
1599 {
1600 Bstr bstrName;
1601 CHECK_ERROR2I_RET(aCPUProfiles[i], COMGETTER(Name)(bstrName.asOutParam()), hrcCheck);
1602 try
1603 {
1604 vecSortedProfiles.push_back(std::pair<com::Bstr, ICPUProfile *>(bstrName, aCPUProfiles[i]));
1605 }
1606 catch (std::bad_alloc &)
1607 {
1608 return E_OUTOFMEMORY;
1609 }
1610 }
1611
1612 std::sort(vecSortedProfiles.begin(), vecSortedProfiles.end());
1613
1614 for (size_t i = 0; i < vecSortedProfiles.size(); i++)
1615 hrc = displayCPUProfile(vecSortedProfiles[i].second, i, cchIdx, fOptLong, hrc);
1616 }
1617
1618 return hrc;
1619}
1620
1621
1622/**
1623 * Translates PartitionType_T to a string if possible.
1624 * @returns read-only string if known value, @a pszUnknown if not.
1625 */
1626static const char *PartitionTypeToString(PartitionType_T enmType, const char *pszUnknown)
1627{
1628#define MY_CASE_STR(a_Type) case RT_CONCAT(PartitionType_,a_Type): return #a_Type
1629 switch (enmType)
1630 {
1631 MY_CASE_STR(Empty);
1632 MY_CASE_STR(FAT12);
1633 MY_CASE_STR(FAT16);
1634 MY_CASE_STR(FAT);
1635 MY_CASE_STR(IFS);
1636 MY_CASE_STR(FAT32CHS);
1637 MY_CASE_STR(FAT32LBA);
1638 MY_CASE_STR(FAT16B);
1639 MY_CASE_STR(Extended);
1640 MY_CASE_STR(WindowsRE);
1641 MY_CASE_STR(LinuxSwapOld);
1642 MY_CASE_STR(LinuxOld);
1643 MY_CASE_STR(DragonFlyBSDSlice);
1644 MY_CASE_STR(LinuxSwap);
1645 MY_CASE_STR(Linux);
1646 MY_CASE_STR(LinuxExtended);
1647 MY_CASE_STR(LinuxLVM);
1648 MY_CASE_STR(BSDSlice);
1649 MY_CASE_STR(AppleUFS);
1650 MY_CASE_STR(AppleHFS);
1651 MY_CASE_STR(Solaris);
1652 MY_CASE_STR(GPT);
1653 MY_CASE_STR(EFI);
1654 MY_CASE_STR(Unknown);
1655 MY_CASE_STR(MBR);
1656 MY_CASE_STR(iFFS);
1657 MY_CASE_STR(SonyBoot);
1658 MY_CASE_STR(LenovoBoot);
1659 MY_CASE_STR(WindowsMSR);
1660 MY_CASE_STR(WindowsBasicData);
1661 MY_CASE_STR(WindowsLDMMeta);
1662 MY_CASE_STR(WindowsLDMData);
1663 MY_CASE_STR(WindowsRecovery);
1664 MY_CASE_STR(WindowsStorageSpaces);
1665 MY_CASE_STR(WindowsStorageReplica);
1666 MY_CASE_STR(IBMGPFS);
1667 MY_CASE_STR(LinuxData);
1668 MY_CASE_STR(LinuxRAID);
1669 MY_CASE_STR(LinuxRootX86);
1670 MY_CASE_STR(LinuxRootAMD64);
1671 MY_CASE_STR(LinuxRootARM32);
1672 MY_CASE_STR(LinuxRootARM64);
1673 MY_CASE_STR(LinuxHome);
1674 MY_CASE_STR(LinuxSrv);
1675 MY_CASE_STR(LinuxPlainDmCrypt);
1676 MY_CASE_STR(LinuxLUKS);
1677 MY_CASE_STR(LinuxReserved);
1678 MY_CASE_STR(FreeBSDBoot);
1679 MY_CASE_STR(FreeBSDData);
1680 MY_CASE_STR(FreeBSDSwap);
1681 MY_CASE_STR(FreeBSDUFS);
1682 MY_CASE_STR(FreeBSDVinum);
1683 MY_CASE_STR(FreeBSDZFS);
1684 MY_CASE_STR(FreeBSDUnknown);
1685 MY_CASE_STR(AppleHFSPlus);
1686 MY_CASE_STR(AppleAPFS);
1687 MY_CASE_STR(AppleRAID);
1688 MY_CASE_STR(AppleRAIDOffline);
1689 MY_CASE_STR(AppleBoot);
1690 MY_CASE_STR(AppleLabel);
1691 MY_CASE_STR(AppleTvRecovery);
1692 MY_CASE_STR(AppleCoreStorage);
1693 MY_CASE_STR(SoftRAIDStatus);
1694 MY_CASE_STR(SoftRAIDScratch);
1695 MY_CASE_STR(SoftRAIDVolume);
1696 MY_CASE_STR(SoftRAIDCache);
1697 MY_CASE_STR(AppleUnknown);
1698 MY_CASE_STR(SolarisBoot);
1699 MY_CASE_STR(SolarisRoot);
1700 MY_CASE_STR(SolarisSwap);
1701 MY_CASE_STR(SolarisBackup);
1702 MY_CASE_STR(SolarisUsr);
1703 MY_CASE_STR(SolarisVar);
1704 MY_CASE_STR(SolarisHome);
1705 MY_CASE_STR(SolarisAltSector);
1706 MY_CASE_STR(SolarisReserved);
1707 MY_CASE_STR(SolarisUnknown);
1708 MY_CASE_STR(NetBSDSwap);
1709 MY_CASE_STR(NetBSDFFS);
1710 MY_CASE_STR(NetBSDLFS);
1711 MY_CASE_STR(NetBSDRAID);
1712 MY_CASE_STR(NetBSDConcatenated);
1713 MY_CASE_STR(NetBSDEncrypted);
1714 MY_CASE_STR(NetBSDUnknown);
1715 MY_CASE_STR(ChromeOSKernel);
1716 MY_CASE_STR(ChromeOSRootFS);
1717 MY_CASE_STR(ChromeOSFuture);
1718 MY_CASE_STR(ContLnxUsr);
1719 MY_CASE_STR(ContLnxRoot);
1720 MY_CASE_STR(ContLnxReserved);
1721 MY_CASE_STR(ContLnxRootRAID);
1722 MY_CASE_STR(HaikuBFS);
1723 MY_CASE_STR(MidntBSDBoot);
1724 MY_CASE_STR(MidntBSDData);
1725 MY_CASE_STR(MidntBSDSwap);
1726 MY_CASE_STR(MidntBSDUFS);
1727 MY_CASE_STR(MidntBSDVium);
1728 MY_CASE_STR(MidntBSDZFS);
1729 MY_CASE_STR(MidntBSDUnknown);
1730 MY_CASE_STR(OpenBSDData);
1731 MY_CASE_STR(QNXPowerSafeFS);
1732 MY_CASE_STR(Plan9);
1733 MY_CASE_STR(VMWareVMKCore);
1734 MY_CASE_STR(VMWareVMFS);
1735 MY_CASE_STR(VMWareReserved);
1736 MY_CASE_STR(VMWareUnknown);
1737 MY_CASE_STR(AndroidX86Bootloader);
1738 MY_CASE_STR(AndroidX86Bootloader2);
1739 MY_CASE_STR(AndroidX86Boot);
1740 MY_CASE_STR(AndroidX86Recovery);
1741 MY_CASE_STR(AndroidX86Misc);
1742 MY_CASE_STR(AndroidX86Metadata);
1743 MY_CASE_STR(AndroidX86System);
1744 MY_CASE_STR(AndroidX86Cache);
1745 MY_CASE_STR(AndroidX86Data);
1746 MY_CASE_STR(AndroidX86Persistent);
1747 MY_CASE_STR(AndroidX86Vendor);
1748 MY_CASE_STR(AndroidX86Config);
1749 MY_CASE_STR(AndroidX86Factory);
1750 MY_CASE_STR(AndroidX86FactoryAlt);
1751 MY_CASE_STR(AndroidX86Fastboot);
1752 MY_CASE_STR(AndroidX86OEM);
1753 MY_CASE_STR(AndroidARMMeta);
1754 MY_CASE_STR(AndroidARMExt);
1755 MY_CASE_STR(ONIEBoot);
1756 MY_CASE_STR(ONIEConfig);
1757 MY_CASE_STR(PowerPCPrep);
1758 MY_CASE_STR(XDGShrBootConfig);
1759 MY_CASE_STR(CephBlock);
1760 MY_CASE_STR(CephBlockDB);
1761 MY_CASE_STR(CephBlockDBDmc);
1762 MY_CASE_STR(CephBlockDBDmcLUKS);
1763 MY_CASE_STR(CephBlockDmc);
1764 MY_CASE_STR(CephBlockDmcLUKS);
1765 MY_CASE_STR(CephBlockWALog);
1766 MY_CASE_STR(CephBlockWALogDmc);
1767 MY_CASE_STR(CephBlockWALogDmcLUKS);
1768 MY_CASE_STR(CephDisk);
1769 MY_CASE_STR(CephDiskDmc);
1770 MY_CASE_STR(CephJournal);
1771 MY_CASE_STR(CephJournalDmc);
1772 MY_CASE_STR(CephJournalDmcLUKS);
1773 MY_CASE_STR(CephLockbox);
1774 MY_CASE_STR(CephMultipathBlock1);
1775 MY_CASE_STR(CephMultipathBlock2);
1776 MY_CASE_STR(CephMultipathBlockDB);
1777 MY_CASE_STR(CephMultipathBLockWALog);
1778 MY_CASE_STR(CephMultipathJournal);
1779 MY_CASE_STR(CephMultipathOSD);
1780 MY_CASE_STR(CephOSD);
1781 MY_CASE_STR(CephOSDDmc);
1782 MY_CASE_STR(CephOSDDmcLUKS);
1783#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
1784 case PartitionType_32BitHack: break;
1785#endif
1786 /* no default! */
1787 }
1788#undef MY_CASE_STR
1789 return pszUnknown;
1790}
1791
1792
1793/**
1794 * List all available host drives with their partitions.
1795 *
1796 * @returns See produceList.
1797 * @param pVirtualBox Reference to the IVirtualBox pointer.
1798 * @param fOptLong Long listing or human readable.
1799 */
1800static HRESULT listHostDrives(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
1801{
1802 HRESULT hrc = S_OK;
1803 ComPtr<IHost> pHost;
1804 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(Host)(pHost.asOutParam()), hrcCheck);
1805 com::SafeIfaceArray<IHostDrive> apHostDrives;
1806 CHECK_ERROR2I_RET(pHost, COMGETTER(HostDrives)(ComSafeArrayAsOutParam(apHostDrives)), hrcCheck);
1807 for (size_t i = 0; i < apHostDrives.size(); ++i)
1808 {
1809 ComPtr<IHostDrive> pHostDrive = apHostDrives[i];
1810
1811 /* The drivePath and model attributes are accessible even when the object
1812 is in 'limited' mode. */
1813 com::Bstr bstrDrivePath;
1814 CHECK_ERROR(pHostDrive,COMGETTER(DrivePath)(bstrDrivePath.asOutParam()));
1815 if (SUCCEEDED(hrc))
1816 RTPrintf(List::tr("%sDrive: %ls\n"), i > 0 ? "\n" : "", bstrDrivePath.raw());
1817 else
1818 RTPrintf(List::tr("%sDrive: %Rhrc\n"), i > 0 ? "\n" : "", hrc);
1819
1820 com::Bstr bstrModel;
1821 CHECK_ERROR(pHostDrive,COMGETTER(Model)(bstrModel.asOutParam()));
1822 if (FAILED(hrc))
1823 RTPrintf(List::tr("Model: %Rhrc\n"), hrc);
1824 else if (bstrModel.isNotEmpty())
1825 RTPrintf(List::tr("Model: \"%ls\"\n"), bstrModel.raw());
1826 else
1827 RTPrintf(List::tr("Model: unknown/inaccessible\n"));
1828
1829 /* The other attributes are not accessible in limited mode and will fail
1830 with E_ACCESSDENIED. Typically means the user cannot read the drive. */
1831 com::Bstr bstrUuidDisk;
1832 hrc = pHostDrive->COMGETTER(Uuid)(bstrUuidDisk.asOutParam());
1833 if (SUCCEEDED(hrc) && !com::Guid(bstrUuidDisk).isZero())
1834 RTPrintf("UUID: %ls\n", bstrUuidDisk.raw());
1835 else if (hrc == E_ACCESSDENIED)
1836 {
1837 RTPrintf(List::tr("Further disk and partitioning information is not available for drive \"%ls\". (E_ACCESSDENIED)\n"),
1838 bstrDrivePath.raw());
1839 continue;
1840 }
1841 else if (FAILED(hrc))
1842 {
1843 RTPrintf("UUID: %Rhrc\n", hrc);
1844 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1845 }
1846
1847 LONG64 cbSize = 0;
1848 hrc = pHostDrive->COMGETTER(Size)(&cbSize);
1849 if (SUCCEEDED(hrc) && fOptLong)
1850 RTPrintf(List::tr("Size: %llu bytes (%Rhcb)\n", "", cbSize), cbSize, cbSize);
1851 else if (SUCCEEDED(hrc))
1852 RTPrintf(List::tr("Size: %Rhcb\n"), cbSize);
1853 else
1854 {
1855 RTPrintf(List::tr("Size: %Rhrc\n"), hrc);
1856 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1857 }
1858
1859 ULONG cbSectorSize = 0;
1860 hrc = pHostDrive->COMGETTER(SectorSize)(&cbSectorSize);
1861 if (SUCCEEDED(hrc))
1862 RTPrintf(List::tr("Sector Size: %u bytes\n", "", cbSectorSize), cbSectorSize);
1863 else
1864 {
1865 RTPrintf(List::tr("Sector Size: %Rhrc\n"), hrc);
1866 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1867 }
1868
1869 PartitioningType_T partitioningType = (PartitioningType_T)9999;
1870 hrc = pHostDrive->COMGETTER(PartitioningType)(&partitioningType);
1871 if (SUCCEEDED(hrc))
1872 RTPrintf(List::tr("Scheme: %s\n"), partitioningType == PartitioningType_MBR ? "MBR" : "GPT");
1873 else
1874 {
1875 RTPrintf(List::tr("Scheme: %Rhrc\n"), hrc);
1876 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1877 }
1878
1879 com::SafeIfaceArray<IHostDrivePartition> apHostDrivesPartitions;
1880 hrc = pHostDrive->COMGETTER(Partitions)(ComSafeArrayAsOutParam(apHostDrivesPartitions));
1881 if (FAILED(hrc))
1882 {
1883 RTPrintf(List::tr("Partitions: %Rhrc\n"), hrc);
1884 com::GlueHandleComErrorNoCtx(pHostDrive, hrc);
1885 }
1886 else if (apHostDrivesPartitions.size() == 0)
1887 RTPrintf(List::tr("Partitions: None (or not able to grok them).\n"));
1888 else if (partitioningType == PartitioningType_MBR)
1889 {
1890 if (fOptLong)
1891 RTPrintf(List::tr("Partitions: First Last\n"
1892 "## Type Byte Size Byte Offset Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1893 else
1894 RTPrintf(List::tr("Partitions: First Last\n"
1895 "## Type Size Start Cyl/Head/Sec Cyl/Head/Sec Active\n"));
1896 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1897 {
1898 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1899
1900 ULONG idx = 0;
1901 CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
1902 ULONG uType = 0;
1903 CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeMBR)(&uType));
1904 ULONG uStartCylinder = 0;
1905 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartCylinder)(&uStartCylinder));
1906 ULONG uStartHead = 0;
1907 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartHead)(&uStartHead));
1908 ULONG uStartSector = 0;
1909 CHECK_ERROR(pHostDrivePartition, COMGETTER(StartSector)(&uStartSector));
1910 ULONG uEndCylinder = 0;
1911 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndCylinder)(&uEndCylinder));
1912 ULONG uEndHead = 0;
1913 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndHead)(&uEndHead));
1914 ULONG uEndSector = 0;
1915 CHECK_ERROR(pHostDrivePartition, COMGETTER(EndSector)(&uEndSector));
1916 cbSize = 0;
1917 CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
1918 LONG64 offStart = 0;
1919 CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
1920 BOOL fActive = 0;
1921 CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
1922 PartitionType_T enmType = PartitionType_Unknown;
1923 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1924
1925 /* Max size & offset here is around 16TiB with 4KiB sectors. */
1926 if (fOptLong) /* cb/off: max 16TiB; idx: max 64. */
1927 RTPrintf("%2u %02x %14llu %14llu %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1928 idx, uType, cbSize, offStart,
1929 uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1930 fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1931 else
1932 RTPrintf("%2u %02x %8Rhcb %8Rhcb %4u/%3u/%2u %4u/%3u/%2u %s %s\n",
1933 idx, uType, (uint64_t)cbSize, (uint64_t)offStart,
1934 uStartCylinder, uStartHead, uStartSector, uEndCylinder, uEndHead, uEndSector,
1935 fActive ? List::tr("yes") : List::tr("no"), PartitionTypeToString(enmType, ""));
1936 }
1937 }
1938 else /* GPT */
1939 {
1940 /* Determin the max partition type length to try reduce the table width: */
1941 size_t cchMaxType = 0;
1942 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1943 {
1944 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1945 PartitionType_T enmType = PartitionType_Unknown;
1946 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1947 size_t const cchTypeNm = strlen(PartitionTypeToString(enmType, "e530bf6d-2754-4e9d-b260-60a5d0b80457"));
1948 cchMaxType = RT_MAX(cchTypeNm, cchMaxType);
1949 }
1950 cchMaxType = RT_MIN(cchMaxType, RTUUID_STR_LENGTH);
1951
1952 if (fOptLong)
1953 RTPrintf(List::tr(
1954 "Partitions:\n"
1955 "## %-*s Uuid Byte Size Byte Offset Active Name\n"),
1956 (int)cchMaxType, List::tr("Type"));
1957 else
1958 RTPrintf(List::tr(
1959 "Partitions:\n"
1960 "## %-*s Uuid Size Start Active Name\n"),
1961 (int)cchMaxType, List::tr("Type"));
1962
1963 for (size_t j = 0; j < apHostDrivesPartitions.size(); ++j)
1964 {
1965 ComPtr<IHostDrivePartition> pHostDrivePartition = apHostDrivesPartitions[j];
1966
1967 ULONG idx = 0;
1968 CHECK_ERROR(pHostDrivePartition, COMGETTER(Number)(&idx));
1969 com::Bstr bstrUuidType;
1970 CHECK_ERROR(pHostDrivePartition, COMGETTER(TypeUuid)(bstrUuidType.asOutParam()));
1971 com::Bstr bstrUuidPartition;
1972 CHECK_ERROR(pHostDrivePartition, COMGETTER(Uuid)(bstrUuidPartition.asOutParam()));
1973 cbSize = 0;
1974 CHECK_ERROR(pHostDrivePartition, COMGETTER(Size)(&cbSize));
1975 LONG64 offStart = 0;
1976 CHECK_ERROR(pHostDrivePartition, COMGETTER(Start)(&offStart));
1977 BOOL fActive = 0;
1978 CHECK_ERROR(pHostDrivePartition, COMGETTER(Active)(&fActive));
1979 com::Bstr bstrName;
1980 CHECK_ERROR(pHostDrivePartition, COMGETTER(Name)(bstrName.asOutParam()));
1981
1982 PartitionType_T enmType = PartitionType_Unknown;
1983 CHECK_ERROR(pHostDrivePartition, COMGETTER(Type)(&enmType));
1984
1985 Utf8Str strTypeConv;
1986 const char *pszTypeNm = PartitionTypeToString(enmType, NULL);
1987 if (!pszTypeNm)
1988 pszTypeNm = (strTypeConv = bstrUuidType).c_str();
1989 else if (strlen(pszTypeNm) >= RTUUID_STR_LENGTH /* includes '\0' */)
1990 pszTypeNm -= RTUUID_STR_LENGTH - 1 - strlen(pszTypeNm);
1991
1992 if (fOptLong)
1993 RTPrintf("%2u %-*s %36ls %19llu %19llu %-3s %ls\n", idx, cchMaxType, pszTypeNm,
1994 bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
1995 bstrName.raw());
1996 else
1997 RTPrintf("%2u %-*s %36ls %8Rhcb %8Rhcb %-3s %ls\n", idx, cchMaxType, pszTypeNm,
1998 bstrUuidPartition.raw(), cbSize, offStart, fActive ? List::tr("on") : List::tr("off"),
1999 bstrName.raw());
2000 }
2001 }
2002 }
2003 return hrc;
2004}
2005
2006
2007/**
2008 * The type of lists we can produce.
2009 */
2010enum ListType_T
2011{
2012 kListNotSpecified = 1000,
2013 kListVMs,
2014 kListRunningVMs,
2015 kListOsTypes,
2016 kListOsVariants,
2017 kListHostDvds,
2018 kListHostFloppies,
2019 kListInternalNetworks,
2020 kListBridgedInterfaces,
2021#if defined(VBOX_WITH_NETFLT)
2022 kListHostOnlyInterfaces,
2023#endif
2024#if defined(VBOX_WITH_VMNET)
2025 kListHostOnlyNetworks,
2026#endif
2027#if defined(VBOX_WITH_CLOUD_NET)
2028 kListCloudNetworks,
2029#endif
2030 kListHostCpuIDs,
2031 kListHostInfo,
2032 kListHddBackends,
2033 kListHdds,
2034 kListDvds,
2035 kListFloppies,
2036 kListUsbHost,
2037 kListUsbFilters,
2038 kListSystemProperties,
2039#if defined(VBOX_WITH_UPDATE_AGENT)
2040 kListUpdateAgents,
2041#endif
2042 kListDhcpServers,
2043 kListExtPacks,
2044 kListGroups,
2045 kListNatNetworks,
2046 kListVideoInputDevices,
2047 kListScreenShotFormats,
2048 kListCloudProviders,
2049 kListCloudProfiles,
2050 kListCPUProfiles,
2051 kListHostDrives
2052};
2053
2054
2055/**
2056 * Produces the specified listing.
2057 *
2058 * @returns S_OK or some COM error code that has been reported in full.
2059 * @param enmList The list to produce.
2060 * @param fOptLong Long (@c true) or short list format.
2061 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
2062 */
2063static HRESULT produceList(enum ListType_T enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
2064{
2065 HRESULT hrc = S_OK;
2066 switch (enmCommand)
2067 {
2068 case kListNotSpecified:
2069 AssertFailed();
2070 return E_FAIL;
2071
2072 case kListVMs:
2073 {
2074 /*
2075 * Get the list of all registered VMs
2076 */
2077 com::SafeIfaceArray<IMachine> machines;
2078 hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2079 if (SUCCEEDED(hrc))
2080 {
2081 /*
2082 * Display it.
2083 */
2084 if (!fOptSorted)
2085 {
2086 for (size_t i = 0; i < machines.size(); ++i)
2087 if (machines[i])
2088 hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2089 }
2090 else
2091 {
2092 /*
2093 * Sort the list by name before displaying it.
2094 */
2095 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
2096 for (size_t i = 0; i < machines.size(); ++i)
2097 {
2098 IMachine *pMachine = machines[i];
2099 if (pMachine) /* no idea why we need to do this... */
2100 {
2101 Bstr bstrName;
2102 pMachine->COMGETTER(Name)(bstrName.asOutParam());
2103 sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
2104 }
2105 }
2106
2107 std::sort(sortedMachines.begin(), sortedMachines.end());
2108
2109 for (size_t i = 0; i < sortedMachines.size(); ++i)
2110 hrc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2111 }
2112 }
2113 break;
2114 }
2115
2116 case kListRunningVMs:
2117 {
2118 /*
2119 * Get the list of all _running_ VMs
2120 */
2121 com::SafeIfaceArray<IMachine> machines;
2122 hrc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
2123 com::SafeArray<MachineState_T> states;
2124 if (SUCCEEDED(hrc))
2125 hrc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
2126 if (SUCCEEDED(hrc))
2127 {
2128 /*
2129 * Iterate through the collection
2130 */
2131 for (size_t i = 0; i < machines.size(); ++i)
2132 {
2133 if (machines[i])
2134 {
2135 MachineState_T machineState = states[i];
2136 switch (machineState)
2137 {
2138 case MachineState_Running:
2139 case MachineState_Teleporting:
2140 case MachineState_LiveSnapshotting:
2141 case MachineState_Paused:
2142 case MachineState_TeleportingPausedVM:
2143 hrc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
2144 break;
2145 default: break; /* Shut up MSC */
2146 }
2147 }
2148 }
2149 }
2150 break;
2151 }
2152
2153 case kListOsTypes:
2154 {
2155 com::SafeIfaceArray<IGuestOSType> coll;
2156 hrc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
2157 if (SUCCEEDED(hrc))
2158 {
2159 /*
2160 * Iterate through the collection.
2161 */
2162 for (size_t i = 0; i < coll.size(); ++i)
2163 {
2164 ComPtr<IGuestOSType> guestOS;
2165 guestOS = coll[i];
2166 Bstr guestId;
2167 guestOS->COMGETTER(Id)(guestId.asOutParam());
2168 RTPrintf("ID: %ls\n", guestId.raw());
2169 Bstr guestDescription;
2170 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
2171 RTPrintf(List::tr("Description: %ls\n"), guestDescription.raw());
2172 Bstr familyId;
2173 guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
2174 RTPrintf(List::tr("Family ID: %ls\n"), familyId.raw());
2175 Bstr familyDescription;
2176 guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
2177 RTPrintf(List::tr("Family Desc: %ls\n"), familyDescription.raw());
2178 Bstr guestOSVariant;
2179 guestOS->COMGETTER(Variant)(guestOSVariant.asOutParam());
2180 if (guestOSVariant.isNotEmpty())
2181 RTPrintf(List::tr("OS Variant: %ls\n"), guestOSVariant.raw());
2182 BOOL is64Bit;
2183 guestOS->COMGETTER(Is64Bit)(&is64Bit);
2184 RTPrintf(List::tr("64 bit: %RTbool\n"), is64Bit);
2185 RTPrintf("\n");
2186 }
2187 }
2188 break;
2189 }
2190
2191 case kListOsVariants:
2192 {
2193 com::SafeArray<BSTR> GuestOSFamilies;
2194 CHECK_ERROR(pVirtualBox, COMGETTER(GuestOSFamilies)(ComSafeArrayAsOutParam(GuestOSFamilies)));
2195 if (SUCCEEDED(hrc))
2196 {
2197 for (size_t i = 0; i < GuestOSFamilies.size(); ++i)
2198 {
2199 const Bstr bstrOSFamily = GuestOSFamilies[i];
2200 com::SafeArray<BSTR> GuestOSVariants;
2201 CHECK_ERROR(pVirtualBox,
2202 GetGuestOSVariantsByFamilyId(bstrOSFamily.raw(),
2203 ComSafeArrayAsOutParam(GuestOSVariants)));
2204 if (SUCCEEDED(hrc))
2205 {
2206 RTPrintf("%ls\n", bstrOSFamily.raw());
2207 for (size_t j = 0; j < GuestOSVariants.size(); ++j)
2208 {
2209 RTPrintf("\t%ls\n", GuestOSVariants[j]);
2210 com::SafeArray<BSTR> GuestOSDescs;
2211 const Bstr bstrOSVariant = GuestOSVariants[j];
2212 CHECK_ERROR(pVirtualBox,
2213 GetGuestOSDescsByVariant(bstrOSVariant.raw(),
2214 ComSafeArrayAsOutParam(GuestOSDescs)));
2215 if (SUCCEEDED(hrc))
2216 for (size_t k = 0; k < GuestOSDescs.size(); ++k)
2217 RTPrintf("\t\t%ls\n", GuestOSDescs[k]);
2218 }
2219 }
2220 }
2221 }
2222 break;
2223 }
2224
2225 case kListHostDvds:
2226 {
2227 ComPtr<IHost> host;
2228 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2229 com::SafeIfaceArray<IMedium> coll;
2230 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
2231 if (SUCCEEDED(hrc))
2232 {
2233 for (size_t i = 0; i < coll.size(); ++i)
2234 {
2235 ComPtr<IMedium> dvdDrive = coll[i];
2236 Bstr uuid;
2237 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
2238 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2239 Bstr location;
2240 dvdDrive->COMGETTER(Location)(location.asOutParam());
2241 RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2242 }
2243 }
2244 break;
2245 }
2246
2247 case kListHostFloppies:
2248 {
2249 ComPtr<IHost> host;
2250 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
2251 com::SafeIfaceArray<IMedium> coll;
2252 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
2253 if (SUCCEEDED(hrc))
2254 {
2255 for (size_t i = 0; i < coll.size(); ++i)
2256 {
2257 ComPtr<IMedium> floppyDrive = coll[i];
2258 Bstr uuid;
2259 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
2260 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
2261 Bstr location;
2262 floppyDrive->COMGETTER(Location)(location.asOutParam());
2263 RTPrintf(List::tr("Name: %ls\n\n"), location.raw());
2264 }
2265 }
2266 break;
2267 }
2268
2269 case kListInternalNetworks:
2270 hrc = listInternalNetworks(pVirtualBox);
2271 break;
2272
2273 case kListBridgedInterfaces:
2274#if defined(VBOX_WITH_NETFLT)
2275 case kListHostOnlyInterfaces:
2276#endif
2277 hrc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
2278 break;
2279
2280#if defined(VBOX_WITH_VMNET)
2281 case kListHostOnlyNetworks:
2282 hrc = listHostOnlyNetworks(pVirtualBox);
2283 break;
2284#endif
2285
2286#if defined(VBOX_WITH_CLOUD_NET)
2287 case kListCloudNetworks:
2288 hrc = listCloudNetworks(pVirtualBox);
2289 break;
2290#endif
2291 case kListHostInfo:
2292 hrc = listHostInfo(pVirtualBox);
2293 break;
2294
2295 case kListHostCpuIDs:
2296 {
2297 ComPtr<IHost> Host;
2298 CHECK_ERROR_BREAK(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
2299 PlatformArchitecture_T platformArch;
2300 CHECK_ERROR_BREAK(Host, COMGETTER(Architecture)(&platformArch));
2301
2302 switch (platformArch)
2303 {
2304 case PlatformArchitecture_x86:
2305 {
2306 ComPtr<IHostX86> HostX86;
2307 CHECK_ERROR_BREAK(Host, COMGETTER(X86)(HostX86.asOutParam()));
2308
2309 RTPrintf(List::tr("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n"));
2310 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
2311 static uint32_t const s_auCpuIdRanges[] =
2312 {
2313 UINT32_C(0x00000000), UINT32_C(0x0000007f),
2314 UINT32_C(0x80000000), UINT32_C(0x8000007f),
2315 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
2316 };
2317 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
2318 {
2319 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
2320 CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
2321 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
2322 continue;
2323 cLeafs++;
2324 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
2325 {
2326 CHECK_ERROR(HostX86, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
2327 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
2328 }
2329 }
2330
2331 break;
2332 }
2333
2334 case PlatformArchitecture_ARM:
2335 {
2336 /** @todo BUGBUG Implement this for ARM! */
2337 break;
2338 }
2339
2340 default:
2341 AssertFailed();
2342 break;
2343 }
2344 break;
2345 }
2346
2347 case kListHddBackends:
2348 hrc = listHddBackends(pVirtualBox);
2349 break;
2350
2351 case kListHdds:
2352 {
2353 com::SafeIfaceArray<IMedium> hdds;
2354 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
2355 hrc = listMedia(pVirtualBox, hdds, List::tr("base"), fOptLong);
2356 break;
2357 }
2358
2359 case kListDvds:
2360 {
2361 com::SafeIfaceArray<IMedium> dvds;
2362 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
2363 hrc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
2364 break;
2365 }
2366
2367 case kListFloppies:
2368 {
2369 com::SafeIfaceArray<IMedium> floppies;
2370 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
2371 hrc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
2372 break;
2373 }
2374
2375 case kListUsbHost:
2376 hrc = listUsbHost(pVirtualBox);
2377 break;
2378
2379 case kListUsbFilters:
2380 hrc = listUsbFilters(pVirtualBox);
2381 break;
2382
2383 case kListSystemProperties:
2384 hrc = listSystemProperties(pVirtualBox);
2385 break;
2386
2387#ifdef VBOX_WITH_UPDATE_AGENT
2388 case kListUpdateAgents:
2389 hrc = listUpdateAgents(pVirtualBox);
2390 break;
2391#endif
2392 case kListDhcpServers:
2393 hrc = listDhcpServers(pVirtualBox);
2394 break;
2395
2396 case kListExtPacks:
2397 hrc = listExtensionPacks(pVirtualBox);
2398 break;
2399
2400 case kListGroups:
2401 hrc = listGroups(pVirtualBox);
2402 break;
2403
2404 case kListNatNetworks:
2405 hrc = listNATNetworks(fOptLong, fOptSorted, pVirtualBox);
2406 break;
2407
2408 case kListVideoInputDevices:
2409 hrc = listVideoInputDevices(pVirtualBox);
2410 break;
2411
2412 case kListScreenShotFormats:
2413 hrc = listScreenShotFormats(pVirtualBox);
2414 break;
2415
2416 case kListCloudProviders:
2417 hrc = listCloudProviders(pVirtualBox);
2418 break;
2419
2420 case kListCloudProfiles:
2421 hrc = listCloudProfiles(pVirtualBox, fOptLong);
2422 break;
2423
2424 case kListCPUProfiles:
2425 hrc = listCPUProfiles(pVirtualBox, fOptLong, fOptSorted);
2426 break;
2427
2428 case kListHostDrives:
2429 hrc = listHostDrives(pVirtualBox, fOptLong);
2430 break;
2431 /* No default here, want gcc warnings. */
2432
2433 } /* end switch */
2434
2435 return hrc;
2436}
2437
2438/**
2439 * Handles the 'list' command.
2440 *
2441 * @returns Appropriate exit code.
2442 * @param a Handler argument.
2443 */
2444RTEXITCODE handleList(HandlerArg *a)
2445{
2446 bool fOptLong = false;
2447 bool fOptMultiple = false;
2448 bool fOptSorted = false;
2449 bool fFirst = true;
2450 enum ListType_T enmOptCommand = kListNotSpecified;
2451 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2452
2453 static const RTGETOPTDEF s_aListOptions[] =
2454 {
2455 { "--long", 'l', RTGETOPT_REQ_NOTHING },
2456 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
2457 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
2458 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
2459 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
2460 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
2461 { "osvariants", kListOsVariants, RTGETOPT_REQ_NOTHING },
2462 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
2463 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
2464 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
2465 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
2466 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
2467#if defined(VBOX_WITH_NETFLT)
2468 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
2469#endif
2470#if defined(VBOX_WITH_VMNET)
2471 { "hostonlynets", kListHostOnlyNetworks, RTGETOPT_REQ_NOTHING },
2472#endif
2473#if defined(VBOX_WITH_CLOUD_NET)
2474 { "cloudnets", kListCloudNetworks, RTGETOPT_REQ_NOTHING },
2475#endif
2476 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2477 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
2478 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
2479 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
2480 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
2481 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
2482 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
2483 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
2484 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
2485 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
2486 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
2487#if defined(VBOX_WITH_UPDATE_AGENT)
2488 { "updates", kListUpdateAgents, RTGETOPT_REQ_NOTHING },
2489#endif
2490 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
2491 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
2492 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
2493 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
2494 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
2495 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
2496 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
2497 { "cpu-profiles", kListCPUProfiles, RTGETOPT_REQ_NOTHING },
2498 { "hostdrives", kListHostDrives, RTGETOPT_REQ_NOTHING },
2499 };
2500
2501 int ch;
2502 RTGETOPTUNION ValueUnion;
2503 RTGETOPTSTATE GetState;
2504 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
2505 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
2506 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
2507 {
2508 switch (ch)
2509 {
2510 case 'l': /* --long */
2511 fOptLong = true;
2512 break;
2513
2514 case 's':
2515 fOptSorted = true;
2516 break;
2517
2518 case 'm':
2519 fOptMultiple = true;
2520 if (enmOptCommand == kListNotSpecified)
2521 break;
2522 ch = enmOptCommand;
2523 RT_FALL_THRU();
2524
2525 case kListVMs:
2526 case kListRunningVMs:
2527 case kListOsTypes:
2528 case kListOsVariants:
2529 case kListHostDvds:
2530 case kListHostFloppies:
2531 case kListInternalNetworks:
2532 case kListBridgedInterfaces:
2533#if defined(VBOX_WITH_NETFLT)
2534 case kListHostOnlyInterfaces:
2535#endif
2536#if defined(VBOX_WITH_VMNET)
2537 case kListHostOnlyNetworks:
2538#endif
2539#if defined(VBOX_WITH_CLOUD_NET)
2540 case kListCloudNetworks:
2541#endif
2542 case kListHostInfo:
2543 case kListHostCpuIDs:
2544 case kListHddBackends:
2545 case kListHdds:
2546 case kListDvds:
2547 case kListFloppies:
2548 case kListUsbHost:
2549 case kListUsbFilters:
2550 case kListSystemProperties:
2551#if defined(VBOX_WITH_UPDATE_AGENT)
2552 case kListUpdateAgents:
2553#endif
2554 case kListDhcpServers:
2555 case kListExtPacks:
2556 case kListGroups:
2557 case kListNatNetworks:
2558 case kListVideoInputDevices:
2559 case kListScreenShotFormats:
2560 case kListCloudProviders:
2561 case kListCloudProfiles:
2562 case kListCPUProfiles:
2563 case kListHostDrives:
2564 enmOptCommand = (enum ListType_T)ch;
2565 if (fOptMultiple)
2566 {
2567 if (fFirst)
2568 fFirst = false;
2569 else
2570 RTPrintf("\n");
2571 RTPrintf("[%s]\n", ValueUnion.pDef->pszLong);
2572 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2573 if (FAILED(hrc))
2574 rcExit = RTEXITCODE_FAILURE;
2575 }
2576 break;
2577
2578 case VINF_GETOPT_NOT_OPTION:
2579 return errorSyntax(List::tr("Unknown subcommand \"%s\"."), ValueUnion.psz);
2580
2581 default:
2582 return errorGetOpt(ch, &ValueUnion);
2583 }
2584 }
2585
2586 /*
2587 * If not in multiple list mode, we have to produce the list now.
2588 */
2589 if (enmOptCommand == kListNotSpecified)
2590 return errorSyntax(List::tr("Missing subcommand for \"list\" command.\n"));
2591 if (!fOptMultiple)
2592 {
2593 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
2594 if (FAILED(hrc))
2595 rcExit = RTEXITCODE_FAILURE;
2596 }
2597
2598 return rcExit;
2599}
2600
2601/* 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