VirtualBox

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

最後變更 在這個檔案從74431是 74431,由 vboxsync 提交於 6 年 前

Main,GUI,VBoxManage: Provide API for proxy settings that picks up the current GUI settings and converts it to SystemProperties XML attributes. Adjusted GUI to use it. Updated VBoxMangage system properties handling accordingly. bugref:9249
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 61.0 KB
行 
1/* $Id: VBoxManageList.cpp 74431 2018-09-24 09:16:17Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'list' command.
4 */
5
6/*
7 * Copyright (C) 2006-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.alldomusa.eu.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#ifndef VBOX_ONLY_DOCS
19
20
21/*********************************************************************************************************************************
22* Header Files *
23*********************************************************************************************************************************/
24#include <VBox/com/com.h>
25#include <VBox/com/string.h>
26#include <VBox/com/Guid.h>
27#include <VBox/com/array.h>
28#include <VBox/com/ErrorInfo.h>
29#include <VBox/com/errorprint.h>
30
31#include <VBox/com/VirtualBox.h>
32
33#include <VBox/log.h>
34#include <iprt/stream.h>
35#include <iprt/string.h>
36#include <iprt/time.h>
37#include <iprt/getopt.h>
38#include <iprt/ctype.h>
39
40#include <vector>
41#include <algorithm>
42
43#include "VBoxManage.h"
44using namespace com;
45
46#ifdef VBOX_WITH_HOSTNETIF_API
47static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
48{
49 switch (enmType)
50 {
51 case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
52 case HostNetworkInterfaceMediumType_PPP: return "PPP";
53 case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
54 case HostNetworkInterfaceMediumType_Unknown: return "Unknown";
55#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
56 case HostNetworkInterfaceMediumType_32BitHack: break; /* Shut up compiler warnings. */
57#endif
58 }
59 return "unknown";
60}
61
62static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus)
63{
64 switch (enmStatus)
65 {
66 case HostNetworkInterfaceStatus_Up: return "Up";
67 case HostNetworkInterfaceStatus_Down: return "Down";
68 case HostNetworkInterfaceStatus_Unknown: return "Unknown";
69#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
70 case HostNetworkInterfaceStatus_32BitHack: break; /* Shut up compiler warnings. */
71#endif
72 }
73 return "unknown";
74}
75#endif /* VBOX_WITH_HOSTNETIF_API */
76
77static const char*getDeviceTypeText(DeviceType_T enmType)
78{
79 switch (enmType)
80 {
81 case DeviceType_HardDisk: return "HardDisk";
82 case DeviceType_DVD: return "DVD";
83 case DeviceType_Floppy: return "Floppy";
84 /* Make MSC happy */
85 case DeviceType_Null: return "Null";
86 case DeviceType_Network: return "Network";
87 case DeviceType_USB: return "USB";
88 case DeviceType_SharedFolder: return "SharedFolder";
89 case DeviceType_Graphics3D: return "Graphics3D";
90#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
91 case DeviceType_32BitHack: break; /* Shut up compiler warnings. */
92#endif
93 }
94 return "Unknown";
95}
96
97
98/**
99 * List internal networks.
100 *
101 * @returns See produceList.
102 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
103 */
104static HRESULT listInternalNetworks(const ComPtr<IVirtualBox> pVirtualBox)
105{
106 HRESULT rc;
107 com::SafeArray<BSTR> internalNetworks;
108 CHECK_ERROR(pVirtualBox, COMGETTER(InternalNetworks)(ComSafeArrayAsOutParam(internalNetworks)));
109 for (size_t i = 0; i < internalNetworks.size(); ++i)
110 {
111 RTPrintf("Name: %ls\n", internalNetworks[i]);
112 }
113 return rc;
114}
115
116
117/**
118 * List network interfaces information (bridged/host only).
119 *
120 * @returns See produceList.
121 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
122 * @param fIsBridged Selects between listing host interfaces (for
123 * use with bridging) or host only interfaces.
124 */
125static HRESULT listNetworkInterfaces(const ComPtr<IVirtualBox> pVirtualBox,
126 bool fIsBridged)
127{
128 HRESULT rc;
129 ComPtr<IHost> host;
130 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
131 com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
132#if defined(VBOX_WITH_NETFLT)
133 if (fIsBridged)
134 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged,
135 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
136 else
137 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly,
138 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
139#else
140 RT_NOREF(fIsBridged);
141 CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
142#endif
143 for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
144 {
145 ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i];
146#ifndef VBOX_WITH_HOSTNETIF_API
147 Bstr interfaceName;
148 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
149 RTPrintf("Name: %ls\n", interfaceName.raw());
150 Guid interfaceGuid;
151 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
152 RTPrintf("GUID: %ls\n\n", Bstr(interfaceGuid.toString()).raw());
153#else /* VBOX_WITH_HOSTNETIF_API */
154 Bstr interfaceName;
155 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
156 RTPrintf("Name: %ls\n", interfaceName.raw());
157 Bstr interfaceGuid;
158 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
159 RTPrintf("GUID: %ls\n", interfaceGuid.raw());
160 BOOL bDHCPEnabled;
161 networkInterface->COMGETTER(DHCPEnabled)(&bDHCPEnabled);
162 RTPrintf("DHCP: %s\n", bDHCPEnabled ? "Enabled" : "Disabled");
163
164 Bstr IPAddress;
165 networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
166 RTPrintf("IPAddress: %ls\n", IPAddress.raw());
167 Bstr NetworkMask;
168 networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
169 RTPrintf("NetworkMask: %ls\n", NetworkMask.raw());
170 Bstr IPV6Address;
171 networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
172 RTPrintf("IPV6Address: %ls\n", IPV6Address.raw());
173 ULONG IPV6NetworkMaskPrefixLength;
174 networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
175 RTPrintf("IPV6NetworkMaskPrefixLength: %d\n", IPV6NetworkMaskPrefixLength);
176 Bstr HardwareAddress;
177 networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
178 RTPrintf("HardwareAddress: %ls\n", HardwareAddress.raw());
179 HostNetworkInterfaceMediumType_T Type;
180 networkInterface->COMGETTER(MediumType)(&Type);
181 RTPrintf("MediumType: %s\n", getHostIfMediumTypeText(Type));
182 BOOL fWireless;
183 networkInterface->COMGETTER(Wireless)(&fWireless);
184 RTPrintf("Wireless: %s\n", fWireless ? "Yes" : "No");
185 HostNetworkInterfaceStatus_T Status;
186 networkInterface->COMGETTER(Status)(&Status);
187 RTPrintf("Status: %s\n", getHostIfStatusText(Status));
188 Bstr netName;
189 networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
190 RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
191#endif
192 }
193 return rc;
194}
195
196
197/**
198 * List host information.
199 *
200 * @returns See produceList.
201 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
202 */
203static HRESULT listHostInfo(const ComPtr<IVirtualBox> pVirtualBox)
204{
205 static struct
206 {
207 ProcessorFeature_T feature;
208 const char *pszName;
209 } features[]
210 =
211 {
212 { ProcessorFeature_HWVirtEx, "HW virtualization" },
213 { ProcessorFeature_PAE, "PAE" },
214 { ProcessorFeature_LongMode, "long mode" },
215 { ProcessorFeature_NestedPaging, "nested paging" },
216 };
217 HRESULT rc;
218 ComPtr<IHost> Host;
219 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
220
221 RTPrintf("Host Information:\n\n");
222
223 LONG64 u64UtcTime = 0;
224 CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
225 RTTIMESPEC timeSpec;
226 char szTime[32];
227 RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
228
229 ULONG processorOnlineCount = 0;
230 CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
231 RTPrintf("Processor online count: %lu\n", processorOnlineCount);
232 ULONG processorCount = 0;
233 CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
234 RTPrintf("Processor count: %lu\n", processorCount);
235 ULONG processorOnlineCoreCount = 0;
236 CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCoreCount)(&processorOnlineCoreCount));
237 RTPrintf("Processor online core count: %lu\n", processorOnlineCoreCount);
238 ULONG processorCoreCount = 0;
239 CHECK_ERROR(Host, COMGETTER(ProcessorCoreCount)(&processorCoreCount));
240 RTPrintf("Processor core count: %lu\n", processorCoreCount);
241 for (unsigned i = 0; i < RT_ELEMENTS(features); i++)
242 {
243 BOOL supported;
244 CHECK_ERROR(Host, GetProcessorFeature(features[i].feature, &supported));
245 RTPrintf("Processor supports %s: %s\n", features[i].pszName, supported ? "yes" : "no");
246 }
247 for (ULONG i = 0; i < processorCount; i++)
248 {
249 ULONG processorSpeed = 0;
250 CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
251 if (processorSpeed)
252 RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
253 else
254 RTPrintf("Processor#%u speed: unknown\n", i);
255 Bstr processorDescription;
256 CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
257 RTPrintf("Processor#%u description: %ls\n", i, processorDescription.raw());
258 }
259
260 ULONG memorySize = 0;
261 CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
262 RTPrintf("Memory size: %lu MByte\n", memorySize);
263
264 ULONG memoryAvailable = 0;
265 CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
266 RTPrintf("Memory available: %lu MByte\n", memoryAvailable);
267
268 Bstr operatingSystem;
269 CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
270 RTPrintf("Operating system: %ls\n", operatingSystem.raw());
271
272 Bstr oSVersion;
273 CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
274 RTPrintf("Operating system version: %ls\n", oSVersion.raw());
275 return rc;
276}
277
278
279/**
280 * List media information.
281 *
282 * @returns See produceList.
283 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
284 * @param aMedia Medium objects to list information for.
285 * @param pszParentUUIDStr String with the parent UUID string (or "base").
286 * @param fOptLong Long (@c true) or short list format.
287 */
288static HRESULT listMedia(const ComPtr<IVirtualBox> pVirtualBox,
289 const com::SafeIfaceArray<IMedium> &aMedia,
290 const char *pszParentUUIDStr,
291 bool fOptLong)
292{
293 HRESULT rc = S_OK;
294 for (size_t i = 0; i < aMedia.size(); ++i)
295 {
296 ComPtr<IMedium> pMedium = aMedia[i];
297
298 rc = showMediumInfo(pVirtualBox, pMedium, pszParentUUIDStr, fOptLong);
299
300 RTPrintf("\n");
301
302 com::SafeIfaceArray<IMedium> children;
303 CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
304 if (children.size() > 0)
305 {
306 Bstr uuid;
307 pMedium->COMGETTER(Id)(uuid.asOutParam());
308
309 // depth first listing of child media
310 rc = listMedia(pVirtualBox, children, Utf8Str(uuid).c_str(), fOptLong);
311 }
312 }
313
314 return rc;
315}
316
317
318/**
319 * List virtual image backends.
320 *
321 * @returns See produceList.
322 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
323 */
324static HRESULT listHddBackends(const ComPtr<IVirtualBox> pVirtualBox)
325{
326 HRESULT rc;
327 ComPtr<ISystemProperties> systemProperties;
328 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
329 com::SafeIfaceArray<IMediumFormat> mediumFormats;
330 CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
331
332 RTPrintf("Supported hard disk backends:\n\n");
333 for (size_t i = 0; i < mediumFormats.size(); ++i)
334 {
335 /* General information */
336 Bstr id;
337 CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam()));
338
339 Bstr description;
340 CHECK_ERROR(mediumFormats[i],
341 COMGETTER(Name)(description.asOutParam()));
342
343 ULONG caps = 0;
344 com::SafeArray <MediumFormatCapabilities_T> mediumFormatCap;
345 CHECK_ERROR(mediumFormats[i],
346 COMGETTER(Capabilities)(ComSafeArrayAsOutParam(mediumFormatCap)));
347 for (ULONG j = 0; j < mediumFormatCap.size(); j++)
348 caps |= mediumFormatCap[j];
349
350
351 RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
352 i, id.raw(), description.raw(), caps);
353
354 /* File extensions */
355 com::SafeArray<BSTR> fileExtensions;
356 com::SafeArray<DeviceType_T> deviceTypes;
357 CHECK_ERROR(mediumFormats[i],
358 DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
359 for (size_t j = 0; j < fileExtensions.size(); ++j)
360 {
361 RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
362 if (j != fileExtensions.size()-1)
363 RTPrintf(",");
364 }
365 RTPrintf("'");
366
367 /* Configuration keys */
368 com::SafeArray<BSTR> propertyNames;
369 com::SafeArray<BSTR> propertyDescriptions;
370 com::SafeArray<DataType_T> propertyTypes;
371 com::SafeArray<ULONG> propertyFlags;
372 com::SafeArray<BSTR> propertyDefaults;
373 CHECK_ERROR(mediumFormats[i],
374 DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
375 ComSafeArrayAsOutParam(propertyDescriptions),
376 ComSafeArrayAsOutParam(propertyTypes),
377 ComSafeArrayAsOutParam(propertyFlags),
378 ComSafeArrayAsOutParam(propertyDefaults)));
379
380 RTPrintf(" properties=(");
381 if (propertyNames.size() > 0)
382 {
383 for (size_t j = 0; j < propertyNames.size(); ++j)
384 {
385 RTPrintf("\n name='%ls' desc='%ls' type=",
386 Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
387 switch (propertyTypes[j])
388 {
389 case DataType_Int32: RTPrintf("int"); break;
390 case DataType_Int8: RTPrintf("byte"); break;
391 case DataType_String: RTPrintf("string"); break;
392#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
393 case DataType_32BitHack: break; /* Shut up compiler warnings. */
394#endif
395 }
396 RTPrintf(" flags=%#04x", propertyFlags[j]);
397 RTPrintf(" default='%ls'", Bstr(propertyDefaults[j]).raw());
398 if (j != propertyNames.size()-1)
399 RTPrintf(", ");
400 }
401 }
402 RTPrintf(")\n");
403 }
404 return rc;
405}
406
407
408/**
409 * List USB devices attached to the host.
410 *
411 * @returns See produceList.
412 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
413 */
414static HRESULT listUsbHost(const ComPtr<IVirtualBox> &pVirtualBox)
415{
416 HRESULT rc;
417 ComPtr<IHost> Host;
418 CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
419
420 SafeIfaceArray<IHostUSBDevice> CollPtr;
421 CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
422
423 RTPrintf("Host USB Devices:\n\n");
424
425 if (CollPtr.size() == 0)
426 {
427 RTPrintf("<none>\n\n");
428 }
429 else
430 {
431 for (size_t i = 0; i < CollPtr.size(); ++i)
432 {
433 ComPtr<IHostUSBDevice> dev = CollPtr[i];
434
435 /* Query info. */
436 Bstr id;
437 CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1);
438 USHORT usVendorId;
439 CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1);
440 USHORT usProductId;
441 CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1);
442 USHORT bcdRevision;
443 CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1);
444 USHORT usPort;
445 CHECK_ERROR_RET(dev, COMGETTER(Port)(&usPort), 1);
446 USHORT usVersion;
447 CHECK_ERROR_RET(dev, COMGETTER(Version)(&usVersion), 1);
448 USHORT usPortVersion;
449 CHECK_ERROR_RET(dev, COMGETTER(PortVersion)(&usPortVersion), 1);
450 USBConnectionSpeed_T enmSpeed;
451 CHECK_ERROR_RET(dev, COMGETTER(Speed)(&enmSpeed), 1);
452
453 RTPrintf("UUID: %s\n"
454 "VendorId: %#06x (%04X)\n"
455 "ProductId: %#06x (%04X)\n"
456 "Revision: %u.%u (%02u%02u)\n"
457 "Port: %u\n",
458 Utf8Str(id).c_str(),
459 usVendorId, usVendorId, usProductId, usProductId,
460 bcdRevision >> 8, bcdRevision & 0xff,
461 bcdRevision >> 8, bcdRevision & 0xff,
462 usPort);
463
464 const char *pszSpeed = "?";
465 switch (enmSpeed)
466 {
467 case USBConnectionSpeed_Low:
468 pszSpeed = "Low";
469 break;
470 case USBConnectionSpeed_Full:
471 pszSpeed = "Full";
472 break;
473 case USBConnectionSpeed_High:
474 pszSpeed = "High";
475 break;
476 case USBConnectionSpeed_Super:
477 pszSpeed = "Super";
478 break;
479 case USBConnectionSpeed_SuperPlus:
480 pszSpeed = "SuperPlus";
481 break;
482 default:
483 ASSERT(false);
484 break;
485 }
486
487 RTPrintf("USB version/speed: %u/%s\n", usVersion, pszSpeed);
488
489 /* optional stuff. */
490 SafeArray<BSTR> CollDevInfo;
491 Bstr bstr;
492 CHECK_ERROR_RET(dev, COMGETTER(DeviceInfo)(ComSafeArrayAsOutParam(CollDevInfo)), 1);
493 if (CollDevInfo.size() >= 1)
494 bstr = Bstr(CollDevInfo[0]);
495 if (!bstr.isEmpty())
496 RTPrintf("Manufacturer: %ls\n", bstr.raw());
497 if (CollDevInfo.size() >= 2)
498 bstr = Bstr(CollDevInfo[1]);
499 if (!bstr.isEmpty())
500 RTPrintf("Product: %ls\n", bstr.raw());
501 CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
502 if (!bstr.isEmpty())
503 RTPrintf("SerialNumber: %ls\n", bstr.raw());
504 CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
505 if (!bstr.isEmpty())
506 RTPrintf("Address: %ls\n", bstr.raw());
507
508 /* current state */
509 USBDeviceState_T state;
510 CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1);
511 const char *pszState = "?";
512 switch (state)
513 {
514 case USBDeviceState_NotSupported:
515 pszState = "Not supported";
516 break;
517 case USBDeviceState_Unavailable:
518 pszState = "Unavailable";
519 break;
520 case USBDeviceState_Busy:
521 pszState = "Busy";
522 break;
523 case USBDeviceState_Available:
524 pszState = "Available";
525 break;
526 case USBDeviceState_Held:
527 pszState = "Held";
528 break;
529 case USBDeviceState_Captured:
530 pszState = "Captured";
531 break;
532 default:
533 ASSERT(false);
534 break;
535 }
536 RTPrintf("Current State: %s\n\n", pszState);
537 }
538 }
539 return rc;
540}
541
542
543/**
544 * List USB filters.
545 *
546 * @returns See produceList.
547 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
548 */
549static HRESULT listUsbFilters(const ComPtr<IVirtualBox> &pVirtualBox)
550{
551 HRESULT rc;
552
553 RTPrintf("Global USB Device Filters:\n\n");
554
555 ComPtr<IHost> host;
556 CHECK_ERROR_RET(pVirtualBox, COMGETTER(Host)(host.asOutParam()), 1);
557
558 SafeIfaceArray<IHostUSBDeviceFilter> coll;
559 CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1);
560
561 if (coll.size() == 0)
562 {
563 RTPrintf("<none>\n\n");
564 }
565 else
566 {
567 for (size_t index = 0; index < coll.size(); ++index)
568 {
569 ComPtr<IHostUSBDeviceFilter> flt = coll[index];
570
571 /* Query info. */
572
573 RTPrintf("Index: %zu\n", index);
574
575 BOOL active = FALSE;
576 CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
577 RTPrintf("Active: %s\n", active ? "yes" : "no");
578
579 USBDeviceFilterAction_T action;
580 CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
581 const char *pszAction = "<invalid>";
582 switch (action)
583 {
584 case USBDeviceFilterAction_Ignore:
585 pszAction = "Ignore";
586 break;
587 case USBDeviceFilterAction_Hold:
588 pszAction = "Hold";
589 break;
590 default:
591 break;
592 }
593 RTPrintf("Action: %s\n", pszAction);
594
595 Bstr bstr;
596 CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
597 RTPrintf("Name: %ls\n", bstr.raw());
598 CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
599 RTPrintf("VendorId: %ls\n", bstr.raw());
600 CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
601 RTPrintf("ProductId: %ls\n", bstr.raw());
602 CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
603 RTPrintf("Revision: %ls\n", bstr.raw());
604 CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
605 RTPrintf("Manufacturer: %ls\n", bstr.raw());
606 CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
607 RTPrintf("Product: %ls\n", bstr.raw());
608 CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
609 RTPrintf("Serial Number: %ls\n\n", bstr.raw());
610 }
611 }
612 return rc;
613}
614
615
616/**
617 * List system properties.
618 *
619 * @returns See produceList.
620 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
621 */
622static HRESULT listSystemProperties(const ComPtr<IVirtualBox> &pVirtualBox)
623{
624 ComPtr<ISystemProperties> systemProperties;
625 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
626
627 Bstr str;
628 ULONG ulValue;
629 LONG64 i64Value;
630 BOOL fValue;
631 const char *psz;
632
633 pVirtualBox->COMGETTER(APIVersion)(str.asOutParam());
634 RTPrintf("API version: %ls\n", str.raw());
635
636 systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
637 RTPrintf("Minimum guest RAM size: %u Megabytes\n", ulValue);
638 systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
639 RTPrintf("Maximum guest RAM size: %u Megabytes\n", ulValue);
640 systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
641 RTPrintf("Minimum video RAM size: %u Megabytes\n", ulValue);
642 systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
643 RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue);
644 systemProperties->COMGETTER(MaxGuestMonitors)(&ulValue);
645 RTPrintf("Maximum guest monitor count: %u\n", ulValue);
646 systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
647 RTPrintf("Minimum guest CPU count: %u\n", ulValue);
648 systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
649 RTPrintf("Maximum guest CPU count: %u\n", ulValue);
650 systemProperties->COMGETTER(InfoVDSize)(&i64Value);
651 RTPrintf("Virtual disk limit (info): %lld Bytes\n", i64Value);
652 systemProperties->COMGETTER(SerialPortCount)(&ulValue);
653 RTPrintf("Maximum Serial Port count: %u\n", ulValue);
654 systemProperties->COMGETTER(ParallelPortCount)(&ulValue);
655 RTPrintf("Maximum Parallel Port count: %u\n", ulValue);
656 systemProperties->COMGETTER(MaxBootPosition)(&ulValue);
657 RTPrintf("Maximum Boot Position: %u\n", ulValue);
658 systemProperties->GetMaxNetworkAdapters(ChipsetType_PIIX3, &ulValue);
659 RTPrintf("Maximum PIIX3 Network Adapter count: %u\n", ulValue);
660 systemProperties->GetMaxNetworkAdapters(ChipsetType_ICH9, &ulValue);
661 RTPrintf("Maximum ICH9 Network Adapter count: %u\n", ulValue);
662 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
663 RTPrintf("Maximum PIIX3 IDE Controllers: %u\n", ulValue);
664 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
665 RTPrintf("Maximum ICH9 IDE Controllers: %u\n", ulValue);
666 systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
667 RTPrintf("Maximum IDE Port count: %u\n", ulValue);
668 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
669 RTPrintf("Maximum Devices per IDE Port: %u\n", ulValue);
670 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
671 RTPrintf("Maximum PIIX3 SATA Controllers: %u\n", ulValue);
672 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
673 RTPrintf("Maximum ICH9 SATA Controllers: %u\n", ulValue);
674 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
675 RTPrintf("Maximum SATA Port count: %u\n", ulValue);
676 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
677 RTPrintf("Maximum Devices per SATA Port: %u\n", ulValue);
678 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
679 RTPrintf("Maximum PIIX3 SCSI Controllers: %u\n", ulValue);
680 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
681 RTPrintf("Maximum ICH9 SCSI Controllers: %u\n", ulValue);
682 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
683 RTPrintf("Maximum SCSI Port count: %u\n", ulValue);
684 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
685 RTPrintf("Maximum Devices per SCSI Port: %u\n", ulValue);
686 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
687 RTPrintf("Maximum SAS PIIX3 Controllers: %u\n", ulValue);
688 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
689 RTPrintf("Maximum SAS ICH9 Controllers: %u\n", ulValue);
690 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
691 RTPrintf("Maximum SAS Port count: %u\n", ulValue);
692 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
693 RTPrintf("Maximum Devices per SAS Port: %u\n", ulValue);
694 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_PCIe, &ulValue);
695 RTPrintf("Maximum NVMe PIIX3 Controllers: %u\n", ulValue);
696 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_PCIe, &ulValue);
697 RTPrintf("Maximum NVMe ICH9 Controllers: %u\n", ulValue);
698 systemProperties->GetMaxPortCountForStorageBus(StorageBus_PCIe, &ulValue);
699 RTPrintf("Maximum NVMe Port count: %u\n", ulValue);
700 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_PCIe, &ulValue);
701 RTPrintf("Maximum Devices per NVMe Port: %u\n", ulValue);
702 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
703 RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue);
704 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
705 RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue);
706 systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
707 RTPrintf("Maximum Floppy Port count: %u\n", ulValue);
708 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
709 RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue);
710#if 0
711 systemProperties->GetFreeDiskSpaceWarning(&i64Value);
712 RTPrintf("Free disk space warning at: %u Bytes\n", i64Value);
713 systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
714 RTPrintf("Free disk space warning at: %u %%\n", ulValue);
715 systemProperties->GetFreeDiskSpaceError(&i64Value);
716 RTPrintf("Free disk space error at: %u Bytes\n", i64Value);
717 systemProperties->GetFreeDiskSpacePercentError(&ulValue);
718 RTPrintf("Free disk space error at: %u %%\n", ulValue);
719#endif
720 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
721 RTPrintf("Default machine folder: %ls\n", str.raw());
722 systemProperties->COMGETTER(RawModeSupported)(&fValue);
723 RTPrintf("Raw-mode Supported: %s\n", fValue ? "yes" : "no");
724 systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
725 RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off");
726 systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
727 RTPrintf("Default hard disk format: %ls\n", str.raw());
728 systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
729 RTPrintf("VRDE auth library: %ls\n", str.raw());
730 systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
731 RTPrintf("Webservice auth. library: %ls\n", str.raw());
732 systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
733 RTPrintf("Remote desktop ExtPack: %ls\n", str.raw());
734 systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
735 RTPrintf("Log history count: %u\n", ulValue);
736 systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
737 RTPrintf("Default frontend: %ls\n", str.raw());
738 AudioDriverType_T enmAudio;
739 systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
740 switch (enmAudio)
741 {
742 case AudioDriverType_Null: psz = "Null"; break;
743 case AudioDriverType_WinMM: psz = "WinMM"; break;
744 case AudioDriverType_OSS: psz = "OSS"; break;
745 case AudioDriverType_ALSA: psz = "ALSA"; break;
746 case AudioDriverType_DirectSound: psz = "DirectSound"; break;
747 case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
748 case AudioDriverType_MMPM: psz = "MMPM"; break;
749 case AudioDriverType_Pulse: psz = "Pulse"; break;
750 case AudioDriverType_SolAudio: psz = "SolAudio"; break;
751 default: psz = "Unknown";
752 }
753 RTPrintf("Default audio driver: %s\n", psz);
754 systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
755 RTPrintf("Autostart database path: %ls\n", str.raw());
756 systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
757 RTPrintf("Default Guest Additions ISO: %ls\n", str.raw());
758 systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
759 RTPrintf("Logging Level: %ls\n", str.raw());
760 ProxyMode_T enmProxyMode = (ProxyMode_T)42;
761 systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
762 psz = "Unknown";
763 switch (enmProxyMode)
764 {
765 case ProxyMode_System: psz = "System"; break;
766 case ProxyMode_NoProxy: psz = "NoProxy"; break;
767 case ProxyMode_Manual: psz = "Manual"; break;
768 }
769 RTPrintf("Proxy Mode: %s\n", psz);
770 systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
771 RTPrintf("Proxy URL: %ls\n", str.raw());
772 return S_OK;
773}
774
775
776/**
777 * List extension packs.
778 *
779 * @returns See produceList.
780 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
781 */
782static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
783{
784 ComObjPtr<IExtPackManager> ptrExtPackMgr;
785 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
786
787 SafeIfaceArray<IExtPack> extPacks;
788 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
789 RTPrintf("Extension Packs: %u\n", extPacks.size());
790
791 HRESULT hrc = S_OK;
792 for (size_t i = 0; i < extPacks.size(); i++)
793 {
794 /* Read all the properties. */
795 Bstr bstrName;
796 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
797 Bstr bstrDesc;
798 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
799 Bstr bstrVersion;
800 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
801 ULONG uRevision;
802 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
803 Bstr bstrEdition;
804 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
805 Bstr bstrVrdeModule;
806 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
807 BOOL fUsable;
808 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
809 Bstr bstrWhy;
810 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
811
812 /* Display them. */
813 if (i)
814 RTPrintf("\n");
815 RTPrintf("Pack no.%2zu: %ls\n"
816 "Version: %ls\n"
817 "Revision: %u\n"
818 "Edition: %ls\n"
819 "Description: %ls\n"
820 "VRDE Module: %ls\n"
821 "Usable: %RTbool\n"
822 "Why unusable: %ls\n",
823 i, bstrName.raw(),
824 bstrVersion.raw(),
825 uRevision,
826 bstrEdition.raw(),
827 bstrDesc.raw(),
828 bstrVrdeModule.raw(),
829 fUsable != FALSE,
830 bstrWhy.raw());
831
832 /* Query plugins and display them. */
833 }
834 return hrc;
835}
836
837
838/**
839 * List machine groups.
840 *
841 * @returns See produceList.
842 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
843 */
844static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
845{
846 SafeArray<BSTR> groups;
847 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
848
849 for (size_t i = 0; i < groups.size(); i++)
850 {
851 RTPrintf("\"%ls\"\n", groups[i]);
852 }
853 return S_OK;
854}
855
856
857/**
858 * List video capture devices.
859 *
860 * @returns See produceList.
861 * @param pVirtualBox Reference to the IVirtualBox pointer.
862 */
863static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox)
864{
865 HRESULT rc;
866 ComPtr<IHost> host;
867 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
868 com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
869 CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
870 RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size());
871 for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
872 {
873 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
874 Bstr name;
875 p->COMGETTER(Name)(name.asOutParam());
876 Bstr path;
877 p->COMGETTER(Path)(path.asOutParam());
878 Bstr alias;
879 p->COMGETTER(Alias)(alias.asOutParam());
880 RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
881 }
882 return rc;
883}
884
885/**
886 * List supported screen shot formats.
887 *
888 * @returns See produceList.
889 * @param pVirtualBox Reference to the IVirtualBox pointer.
890 */
891static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> pVirtualBox)
892{
893 HRESULT rc = S_OK;
894 ComPtr<ISystemProperties> systemProperties;
895 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
896 com::SafeArray<BitmapFormat_T> formats;
897 CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
898
899 RTPrintf("Supported %d screen shot formats:\n", formats.size());
900 for (size_t i = 0; i < formats.size(); ++i)
901 {
902 uint32_t u32Format = (uint32_t)formats[i];
903 char szFormat[5];
904 szFormat[0] = RT_BYTE1(u32Format);
905 szFormat[1] = RT_BYTE2(u32Format);
906 szFormat[2] = RT_BYTE3(u32Format);
907 szFormat[3] = RT_BYTE4(u32Format);
908 szFormat[4] = 0;
909 RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
910 }
911 return rc;
912}
913
914/**
915 * List available cloud providers.
916 *
917 * @returns See produceList.
918 * @param pVirtualBox Reference to the IVirtualBox pointer.
919 */
920static HRESULT listCloudProviders(const ComPtr<IVirtualBox> pVirtualBox)
921{
922 HRESULT rc = S_OK;
923 ComPtr<ICloudProviderManager> pCloudProviderManager;
924 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
925 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
926 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
927
928 RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size());
929 for (size_t i = 0; i < apCloudProviders.size(); ++i)
930 {
931 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
932 Bstr bstrProviderName;
933 pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
934 RTPrintf("Name: %ls\n", bstrProviderName.raw());
935 pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
936 RTPrintf("Short Name: %ls\n", bstrProviderName.raw());
937 Bstr bstrProviderID;
938 pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
939 RTPrintf("GUID: %ls\n", bstrProviderID.raw());
940
941 RTPrintf("\n");
942 }
943 return rc;
944}
945
946
947/**
948 * List all available cloud profiles (by iterating over the cloud providers).
949 *
950 * @returns See produceList.
951 * @param pVirtualBox Reference to the IVirtualBox pointer.
952 * @param fOptLong If true, list all profile properties.
953 */
954static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
955{
956 HRESULT rc = S_OK;
957 ComPtr<ICloudProviderManager> pCloudProviderManager;
958 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
959 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
960 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
961
962 for (size_t i = 0; i < apCloudProviders.size(); ++i)
963 {
964 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
965 com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
966 CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
967 for (size_t j = 0; j < apCloudProfiles.size(); ++j)
968 {
969 ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
970 Bstr bstrProfileName;
971 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
972 RTPrintf("Name: %ls\n", bstrProfileName.raw());
973 Bstr bstrProviderID;
974 pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
975 RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
976
977 if (fOptLong)
978 {
979 com::SafeArray<BSTR> names;
980 com::SafeArray<BSTR> values;
981 pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
982 size_t cNames = names.size();
983 size_t cValues = values.size();
984 bool fFirst = true;
985 for (size_t k = 0; k < cNames; k++)
986 {
987 Bstr value;
988 if (k < cValues)
989 value = values[k];
990 RTPrintf("%s%ls=%ls\n",
991 fFirst ? "Property: " : " ",
992 names[k], value.raw());
993 fFirst = false;
994 }
995 }
996
997 RTPrintf("\n");
998 }
999 }
1000 return rc;
1001}
1002
1003
1004/**
1005 * The type of lists we can produce.
1006 */
1007enum enmListType
1008{
1009 kListNotSpecified = 1000,
1010 kListVMs,
1011 kListRunningVMs,
1012 kListOsTypes,
1013 kListHostDvds,
1014 kListHostFloppies,
1015 kListInternalNetworks,
1016 kListBridgedInterfaces,
1017#if defined(VBOX_WITH_NETFLT)
1018 kListHostOnlyInterfaces,
1019#endif
1020 kListHostCpuIDs,
1021 kListHostInfo,
1022 kListHddBackends,
1023 kListHdds,
1024 kListDvds,
1025 kListFloppies,
1026 kListUsbHost,
1027 kListUsbFilters,
1028 kListSystemProperties,
1029 kListDhcpServers,
1030 kListExtPacks,
1031 kListGroups,
1032 kListNatNetworks,
1033 kListVideoInputDevices,
1034 kListScreenShotFormats,
1035 kListCloudProviders,
1036 kListCloudProfiles,
1037};
1038
1039
1040/**
1041 * Produces the specified listing.
1042 *
1043 * @returns S_OK or some COM error code that has been reported in full.
1044 * @param enmList The list to produce.
1045 * @param fOptLong Long (@c true) or short list format.
1046 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1047 */
1048static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
1049{
1050 HRESULT rc = S_OK;
1051 switch (enmCommand)
1052 {
1053 case kListNotSpecified:
1054 AssertFailed();
1055 return E_FAIL;
1056
1057 case kListVMs:
1058 {
1059 /*
1060 * Get the list of all registered VMs
1061 */
1062 com::SafeIfaceArray<IMachine> machines;
1063 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1064 if (SUCCEEDED(rc))
1065 {
1066 /*
1067 * Display it.
1068 */
1069 if (!fOptSorted)
1070 {
1071 for (size_t i = 0; i < machines.size(); ++i)
1072 if (machines[i])
1073 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1074 }
1075 else
1076 {
1077 /*
1078 * Sort the list by name before displaying it.
1079 */
1080 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
1081 for (size_t i = 0; i < machines.size(); ++i)
1082 {
1083 IMachine *pMachine = machines[i];
1084 if (pMachine) /* no idea why we need to do this... */
1085 {
1086 Bstr bstrName;
1087 pMachine->COMGETTER(Name)(bstrName.asOutParam());
1088 sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
1089 }
1090 }
1091
1092 std::sort(sortedMachines.begin(), sortedMachines.end());
1093
1094 for (size_t i = 0; i < sortedMachines.size(); ++i)
1095 rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1096 }
1097 }
1098 break;
1099 }
1100
1101 case kListRunningVMs:
1102 {
1103 /*
1104 * Get the list of all _running_ VMs
1105 */
1106 com::SafeIfaceArray<IMachine> machines;
1107 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1108 com::SafeArray<MachineState_T> states;
1109 if (SUCCEEDED(rc))
1110 rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
1111 if (SUCCEEDED(rc))
1112 {
1113 /*
1114 * Iterate through the collection
1115 */
1116 for (size_t i = 0; i < machines.size(); ++i)
1117 {
1118 if (machines[i])
1119 {
1120 MachineState_T machineState = states[i];
1121 switch (machineState)
1122 {
1123 case MachineState_Running:
1124 case MachineState_Teleporting:
1125 case MachineState_LiveSnapshotting:
1126 case MachineState_Paused:
1127 case MachineState_TeleportingPausedVM:
1128 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1129 break;
1130 default: break; /* Shut up MSC */
1131 }
1132 }
1133 }
1134 }
1135 break;
1136 }
1137
1138 case kListOsTypes:
1139 {
1140 com::SafeIfaceArray<IGuestOSType> coll;
1141 rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
1142 if (SUCCEEDED(rc))
1143 {
1144 /*
1145 * Iterate through the collection.
1146 */
1147 for (size_t i = 0; i < coll.size(); ++i)
1148 {
1149 ComPtr<IGuestOSType> guestOS;
1150 guestOS = coll[i];
1151 Bstr guestId;
1152 guestOS->COMGETTER(Id)(guestId.asOutParam());
1153 RTPrintf("ID: %ls\n", guestId.raw());
1154 Bstr guestDescription;
1155 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
1156 RTPrintf("Description: %ls\n", guestDescription.raw());
1157 Bstr familyId;
1158 guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
1159 RTPrintf("Family ID: %ls\n", familyId.raw());
1160 Bstr familyDescription;
1161 guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
1162 RTPrintf("Family Desc: %ls\n", familyDescription.raw());
1163 BOOL is64Bit;
1164 guestOS->COMGETTER(Is64Bit)(&is64Bit);
1165 RTPrintf("64 bit: %RTbool\n", is64Bit);
1166 RTPrintf("\n");
1167 }
1168 }
1169 break;
1170 }
1171
1172 case kListHostDvds:
1173 {
1174 ComPtr<IHost> host;
1175 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1176 com::SafeIfaceArray<IMedium> coll;
1177 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
1178 if (SUCCEEDED(rc))
1179 {
1180 for (size_t i = 0; i < coll.size(); ++i)
1181 {
1182 ComPtr<IMedium> dvdDrive = coll[i];
1183 Bstr uuid;
1184 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
1185 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1186 Bstr location;
1187 dvdDrive->COMGETTER(Location)(location.asOutParam());
1188 RTPrintf("Name: %ls\n\n", location.raw());
1189 }
1190 }
1191 break;
1192 }
1193
1194 case kListHostFloppies:
1195 {
1196 ComPtr<IHost> host;
1197 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1198 com::SafeIfaceArray<IMedium> coll;
1199 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
1200 if (SUCCEEDED(rc))
1201 {
1202 for (size_t i = 0; i < coll.size(); ++i)
1203 {
1204 ComPtr<IMedium> floppyDrive = coll[i];
1205 Bstr uuid;
1206 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
1207 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1208 Bstr location;
1209 floppyDrive->COMGETTER(Location)(location.asOutParam());
1210 RTPrintf("Name: %ls\n\n", location.raw());
1211 }
1212 }
1213 break;
1214 }
1215
1216 case kListInternalNetworks:
1217 rc = listInternalNetworks(pVirtualBox);
1218 break;
1219
1220 case kListBridgedInterfaces:
1221#if defined(VBOX_WITH_NETFLT)
1222 case kListHostOnlyInterfaces:
1223#endif
1224 rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
1225 break;
1226
1227 case kListHostInfo:
1228 rc = listHostInfo(pVirtualBox);
1229 break;
1230
1231 case kListHostCpuIDs:
1232 {
1233 ComPtr<IHost> Host;
1234 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
1235
1236 RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
1237 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
1238 static uint32_t const s_auCpuIdRanges[] =
1239 {
1240 UINT32_C(0x00000000), UINT32_C(0x0000007f),
1241 UINT32_C(0x80000000), UINT32_C(0x8000007f),
1242 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
1243 };
1244 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
1245 {
1246 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
1247 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
1248 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
1249 continue;
1250 cLeafs++;
1251 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
1252 {
1253 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
1254 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
1255 }
1256 }
1257 break;
1258 }
1259
1260 case kListHddBackends:
1261 rc = listHddBackends(pVirtualBox);
1262 break;
1263
1264 case kListHdds:
1265 {
1266 com::SafeIfaceArray<IMedium> hdds;
1267 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
1268 rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
1269 break;
1270 }
1271
1272 case kListDvds:
1273 {
1274 com::SafeIfaceArray<IMedium> dvds;
1275 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
1276 rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
1277 break;
1278 }
1279
1280 case kListFloppies:
1281 {
1282 com::SafeIfaceArray<IMedium> floppies;
1283 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
1284 rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
1285 break;
1286 }
1287
1288 case kListUsbHost:
1289 rc = listUsbHost(pVirtualBox);
1290 break;
1291
1292 case kListUsbFilters:
1293 rc = listUsbFilters(pVirtualBox);
1294 break;
1295
1296 case kListSystemProperties:
1297 rc = listSystemProperties(pVirtualBox);
1298 break;
1299
1300 case kListDhcpServers:
1301 {
1302 com::SafeIfaceArray<IDHCPServer> svrs;
1303 CHECK_ERROR(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)));
1304 for (size_t i = 0; i < svrs.size(); ++i)
1305 {
1306 ComPtr<IDHCPServer> svr = svrs[i];
1307 Bstr netName;
1308 svr->COMGETTER(NetworkName)(netName.asOutParam());
1309 RTPrintf("NetworkName: %ls\n", netName.raw());
1310 Bstr ip;
1311 svr->COMGETTER(IPAddress)(ip.asOutParam());
1312 RTPrintf("IP: %ls\n", ip.raw());
1313 Bstr netmask;
1314 svr->COMGETTER(NetworkMask)(netmask.asOutParam());
1315 RTPrintf("NetworkMask: %ls\n", netmask.raw());
1316 Bstr lowerIp;
1317 svr->COMGETTER(LowerIP)(lowerIp.asOutParam());
1318 RTPrintf("lowerIPAddress: %ls\n", lowerIp.raw());
1319 Bstr upperIp;
1320 svr->COMGETTER(UpperIP)(upperIp.asOutParam());
1321 RTPrintf("upperIPAddress: %ls\n", upperIp.raw());
1322 BOOL fEnabled;
1323 svr->COMGETTER(Enabled)(&fEnabled);
1324 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1325 RTPrintf("\n");
1326 }
1327 break;
1328 }
1329
1330 case kListExtPacks:
1331 rc = listExtensionPacks(pVirtualBox);
1332 break;
1333
1334 case kListGroups:
1335 rc = listGroups(pVirtualBox);
1336 break;
1337
1338 case kListNatNetworks:
1339 {
1340 com::SafeIfaceArray<INATNetwork> nets;
1341 CHECK_ERROR(pVirtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nets)));
1342 for (size_t i = 0; i < nets.size(); ++i)
1343 {
1344 ComPtr<INATNetwork> net = nets[i];
1345 Bstr netName;
1346 net->COMGETTER(NetworkName)(netName.asOutParam());
1347 RTPrintf("NetworkName: %ls\n", netName.raw());
1348 Bstr gateway;
1349 net->COMGETTER(Gateway)(gateway.asOutParam());
1350 RTPrintf("IP: %ls\n", gateway.raw());
1351 Bstr network;
1352 net->COMGETTER(Network)(network.asOutParam());
1353 RTPrintf("Network: %ls\n", network.raw());
1354 BOOL fEnabled;
1355 net->COMGETTER(IPv6Enabled)(&fEnabled);
1356 RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No");
1357 Bstr ipv6prefix;
1358 net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
1359 RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw());
1360 net->COMGETTER(NeedDhcpServer)(&fEnabled);
1361 RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No");
1362 net->COMGETTER(Enabled)(&fEnabled);
1363 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1364
1365#define PRINT_STRING_ARRAY(title) \
1366 if (strs.size() > 0) \
1367 { \
1368 RTPrintf(title); \
1369 size_t j = 0; \
1370 for (;j < strs.size(); ++j) \
1371 RTPrintf(" %s\n", Utf8Str(strs[j]).c_str()); \
1372 }
1373
1374 com::SafeArray<BSTR> strs;
1375
1376 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs)));
1377 PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n");
1378 strs.setNull();
1379
1380 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs)));
1381 PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n");
1382 strs.setNull();
1383
1384 CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs)));
1385 PRINT_STRING_ARRAY("loopback mappings (ipv4)\n");
1386 strs.setNull();
1387
1388#undef PRINT_STRING_ARRAY
1389 RTPrintf("\n");
1390 }
1391 break;
1392 }
1393
1394 case kListVideoInputDevices:
1395 rc = listVideoInputDevices(pVirtualBox);
1396 break;
1397
1398 case kListScreenShotFormats:
1399 rc = listScreenShotFormats(pVirtualBox);
1400 break;
1401
1402 case kListCloudProviders:
1403 rc = listCloudProviders(pVirtualBox);
1404 break;
1405
1406 case kListCloudProfiles:
1407 rc = listCloudProfiles(pVirtualBox, fOptLong);
1408 break;
1409
1410 /* No default here, want gcc warnings. */
1411
1412 } /* end switch */
1413
1414 return rc;
1415}
1416
1417/**
1418 * Handles the 'list' command.
1419 *
1420 * @returns Appropriate exit code.
1421 * @param a Handler argument.
1422 */
1423RTEXITCODE handleList(HandlerArg *a)
1424{
1425 bool fOptLong = false;
1426 bool fOptMultiple = false;
1427 bool fOptSorted = false;
1428 enum enmListType enmOptCommand = kListNotSpecified;
1429
1430 static const RTGETOPTDEF s_aListOptions[] =
1431 {
1432 { "--long", 'l', RTGETOPT_REQ_NOTHING },
1433 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
1434 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
1435 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
1436 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
1437 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
1438 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
1439 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
1440 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
1441 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
1442 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
1443#if defined(VBOX_WITH_NETFLT)
1444 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
1445#endif
1446 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1447 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1448 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
1449 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
1450 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
1451 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
1452 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
1453 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
1454 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
1455 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
1456 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
1457 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
1458 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
1459 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
1460 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
1461 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
1462 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
1463 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
1464 };
1465
1466 int ch;
1467 RTGETOPTUNION ValueUnion;
1468 RTGETOPTSTATE GetState;
1469 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
1470 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1471 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1472 {
1473 switch (ch)
1474 {
1475 case 'l': /* --long */
1476 fOptLong = true;
1477 break;
1478
1479 case 's':
1480 fOptSorted = true;
1481 break;
1482
1483 case 'm':
1484 fOptMultiple = true;
1485 if (enmOptCommand == kListNotSpecified)
1486 break;
1487 ch = enmOptCommand;
1488 RT_FALL_THRU();
1489
1490 case kListVMs:
1491 case kListRunningVMs:
1492 case kListOsTypes:
1493 case kListHostDvds:
1494 case kListHostFloppies:
1495 case kListInternalNetworks:
1496 case kListBridgedInterfaces:
1497#if defined(VBOX_WITH_NETFLT)
1498 case kListHostOnlyInterfaces:
1499#endif
1500 case kListHostInfo:
1501 case kListHostCpuIDs:
1502 case kListHddBackends:
1503 case kListHdds:
1504 case kListDvds:
1505 case kListFloppies:
1506 case kListUsbHost:
1507 case kListUsbFilters:
1508 case kListSystemProperties:
1509 case kListDhcpServers:
1510 case kListExtPacks:
1511 case kListGroups:
1512 case kListNatNetworks:
1513 case kListVideoInputDevices:
1514 case kListScreenShotFormats:
1515 case kListCloudProviders:
1516 case kListCloudProfiles:
1517 enmOptCommand = (enum enmListType)ch;
1518 if (fOptMultiple)
1519 {
1520 HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox);
1521 if (FAILED(hrc))
1522 return RTEXITCODE_FAILURE;
1523 }
1524 break;
1525
1526 case VINF_GETOPT_NOT_OPTION:
1527 return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
1528
1529 default:
1530 return errorGetOpt(USAGE_LIST, ch, &ValueUnion);
1531 }
1532 }
1533
1534 /*
1535 * If not in multiple list mode, we have to produce the list now.
1536 */
1537 if (enmOptCommand == kListNotSpecified)
1538 return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
1539 if (!fOptMultiple)
1540 {
1541 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
1542 if (FAILED(hrc))
1543 return RTEXITCODE_FAILURE;
1544 }
1545
1546 return RTEXITCODE_SUCCESS;
1547}
1548
1549#endif /* !VBOX_ONLY_DOCS */
1550/* vi: set tabstop=4 shiftwidth=4 expandtab: */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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