VirtualBox

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

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

include/VBox/usbfilter.h,HostDrivers/VBoxUSB/USBFilter: IUSBDeviceFilter:
USB device interval filters don't work. bugref:10452

Main/Host,Main/USBDeviceFilter: Adding or removing global USB device
filters causes memory corruption wihch can lead to a deadlock or a SEGV
as the list of global USB device filters (llChildren) changes while
the list is being walked.

Frontends/VBoxManage: 'VBoxManage list usbfilters' doesn't display the
'Port' value of the device filter.

Frontends/VBoxManage: 'VBoxManage add usbfilter' and 'VBoxManage modify
usbfilter' both ignore the --product="Value" option.

Main/VirtualBox.xidl: Improve the IUSBDeviceFilter wording to make
things clearer in the 'VirtualBox Programming Guide and Reference Guide'
aka SDKRef.pdf.

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