VirtualBox

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

Last change on this file since 99844 was 98103, checked in by vboxsync, 2 years ago

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

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