VirtualBox

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

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

VBoxManage/list dhcpservers: Reimplemented using revamped interface. bugref:9288
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 67.7 KB
行 
1/* $Id: VBoxManageList.cpp 79748 2019-07-12 23:01:35Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'list' command.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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 fDHCPEnabled = FALSE;
161 networkInterface->COMGETTER(DHCPEnabled)(&fDHCPEnabled);
162 RTPrintf("DHCP: %s\n", fDHCPEnabled ? "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 = FALSE;
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_VirtioSCSI, &ulValue);
703 RTPrintf("Maximum virtio-scsi PIIX3 Controllers: %u\n", ulValue);
704 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_VirtioSCSI, &ulValue);
705 RTPrintf("Maximum virtio-scsi ICH9 Controllers: %u\n", ulValue);
706 systemProperties->GetMaxPortCountForStorageBus(StorageBus_VirtioSCSI, &ulValue);
707 RTPrintf("Maximum virtio-scsi Port count: %u\n", ulValue);
708 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_VirtioSCSI, &ulValue);
709 RTPrintf("Maximum Devices per virtio-scsi Port: %u\n", ulValue);
710 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
711 RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue);
712 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
713 RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue);
714 systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
715 RTPrintf("Maximum Floppy Port count: %u\n", ulValue);
716 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
717 RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue);
718#if 0
719 systemProperties->GetFreeDiskSpaceWarning(&i64Value);
720 RTPrintf("Free disk space warning at: %u Bytes\n", i64Value);
721 systemProperties->GetFreeDiskSpacePercentWarning(&ulValue);
722 RTPrintf("Free disk space warning at: %u %%\n", ulValue);
723 systemProperties->GetFreeDiskSpaceError(&i64Value);
724 RTPrintf("Free disk space error at: %u Bytes\n", i64Value);
725 systemProperties->GetFreeDiskSpacePercentError(&ulValue);
726 RTPrintf("Free disk space error at: %u %%\n", ulValue);
727#endif
728 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
729 RTPrintf("Default machine folder: %ls\n", str.raw());
730 systemProperties->COMGETTER(RawModeSupported)(&fValue);
731 RTPrintf("Raw-mode Supported: %s\n", fValue ? "yes" : "no");
732 systemProperties->COMGETTER(ExclusiveHwVirt)(&fValue);
733 RTPrintf("Exclusive HW virtualization use: %s\n", fValue ? "on" : "off");
734 systemProperties->COMGETTER(DefaultHardDiskFormat)(str.asOutParam());
735 RTPrintf("Default hard disk format: %ls\n", str.raw());
736 systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
737 RTPrintf("VRDE auth library: %ls\n", str.raw());
738 systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
739 RTPrintf("Webservice auth. library: %ls\n", str.raw());
740 systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
741 RTPrintf("Remote desktop ExtPack: %ls\n", str.raw());
742 systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
743 RTPrintf("Log history count: %u\n", ulValue);
744 systemProperties->COMGETTER(DefaultFrontend)(str.asOutParam());
745 RTPrintf("Default frontend: %ls\n", str.raw());
746 AudioDriverType_T enmAudio;
747 systemProperties->COMGETTER(DefaultAudioDriver)(&enmAudio);
748 switch (enmAudio)
749 {
750 case AudioDriverType_Null: psz = "Null"; break;
751 case AudioDriverType_WinMM: psz = "WinMM"; break;
752 case AudioDriverType_OSS: psz = "OSS"; break;
753 case AudioDriverType_ALSA: psz = "ALSA"; break;
754 case AudioDriverType_DirectSound: psz = "DirectSound"; break;
755 case AudioDriverType_CoreAudio: psz = "CoreAudio"; break;
756 case AudioDriverType_MMPM: psz = "MMPM"; break;
757 case AudioDriverType_Pulse: psz = "Pulse"; break;
758 case AudioDriverType_SolAudio: psz = "SolAudio"; break;
759 default: psz = "Unknown";
760 }
761 RTPrintf("Default audio driver: %s\n", psz);
762 systemProperties->COMGETTER(AutostartDatabasePath)(str.asOutParam());
763 RTPrintf("Autostart database path: %ls\n", str.raw());
764 systemProperties->COMGETTER(DefaultAdditionsISO)(str.asOutParam());
765 RTPrintf("Default Guest Additions ISO: %ls\n", str.raw());
766 systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
767 RTPrintf("Logging Level: %ls\n", str.raw());
768 ProxyMode_T enmProxyMode = (ProxyMode_T)42;
769 systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
770 psz = "Unknown";
771 switch (enmProxyMode)
772 {
773 case ProxyMode_System: psz = "System"; break;
774 case ProxyMode_NoProxy: psz = "NoProxy"; break;
775 case ProxyMode_Manual: psz = "Manual"; break;
776#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
777 case ProxyMode_32BitHack: break; /* Shut up compiler warnings. */
778#endif
779 }
780 RTPrintf("Proxy Mode: %s\n", psz);
781 systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
782 RTPrintf("Proxy URL: %ls\n", str.raw());
783 return S_OK;
784}
785
786
787/**
788 * Helper for listDhcpServers() that shows a DHCP configuration.
789 */
790static HRESULT showDhcpConfig(ComPtr<IDHCPConfig> ptrConfig)
791{
792 HRESULT hrcRet = S_OK;
793
794 ULONG secs = 0;
795 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MinLeaseTime)(&secs), hrcRet = hrcCheck);
796 if (secs == 0)
797 RTPrintf(" minLeaseTime: default\n");
798 else
799 RTPrintf(" minLeaseTime: %u sec\n", secs);
800
801 secs = 0;
802 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(DefaultLeaseTime)(&secs), hrcRet = hrcCheck);
803 if (secs == 0)
804 RTPrintf(" defaultLeaseTime: default\n");
805 else
806 RTPrintf(" defaultLeaseTime: %u sec\n", secs);
807
808 secs = 0;
809 CHECK_ERROR2I_STMT(ptrConfig, COMGETTER(MaxLeaseTime)(&secs), hrcRet = hrcCheck);
810 if (secs == 0)
811 RTPrintf(" maxLeaseTime: default\n");
812 else
813 RTPrintf(" maxLeaseTime: %u sec\n", secs);
814
815 com::SafeArray<DhcpOpt_T> Options;
816 com::SafeArray<DHCPOptionEncoding_T> Encodings;
817 com::SafeArray<BSTR> Values;
818 HRESULT hrc;
819 CHECK_ERROR2_STMT(hrc, ptrConfig, GetAllOptions(ComSafeArrayAsOutParam(Options),
820 ComSafeArrayAsOutParam(Encodings),
821 ComSafeArrayAsOutParam(Values)), hrcRet = hrc);
822 if (FAILED(hrc))
823 RTPrintf(" DHCP options: %Rhrc\n", hrc);
824 else if (Options.size() != Encodings.size() || Options.size() != Values.size())
825 {
826 RTPrintf(" DHCP options: Return count mismatch: %zu, %zu, %zu\n", Options.size(), Encodings.size(), Values.size());
827 hrcRet = E_FAIL;
828 }
829 else if (Options.size() == 0)
830 RTPrintf(" DHCP options: None\n");
831 else
832 for (size_t i = 0; i < Options.size(); i++)
833 {
834 switch (Encodings[i])
835 {
836 case DHCPOptionEncoding_Legacy:
837 RTPrintf(" %3d/legacy: %ls\n", Options[i], Values[i]);
838 break;
839 case DHCPOptionEncoding_Hex:
840 RTPrintf(" %3d/hex: %ls\n", Options[i], Values[i]);
841 break;
842 default:
843 RTPrintf(" %3d/%u?: %ls\n", Options[i], Encodings[i], Values[i]);
844 break;
845 }
846 }
847
848 return S_OK;
849}
850
851
852/**
853 * List DHCP servers.
854 *
855 * @returns See produceList.
856 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
857 */
858static HRESULT listDhcpServers(const ComPtr<IVirtualBox> &pVirtualBox)
859{
860 HRESULT hrcRet = S_OK;
861 com::SafeIfaceArray<IDHCPServer> svrs;
862 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)), hrcCheck);
863 for (size_t i = 0; i < svrs.size(); ++i)
864 {
865 if (i > 0)
866 RTPrintf("\n");
867
868 ComPtr<IDHCPServer> svr = svrs[i];
869 Bstr bstr;
870 CHECK_ERROR2I_STMT(svr, COMGETTER(NetworkName)(bstr.asOutParam()), hrcRet = hrcCheck);
871 RTPrintf("NetworkName: %ls\n", bstr.raw());
872
873 CHECK_ERROR2I_STMT(svr, COMGETTER(IPAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
874 RTPrintf("Dhcpd IP: %ls\n", bstr.raw());
875
876 CHECK_ERROR2I_STMT(svr, COMGETTER(LowerIP)(bstr.asOutParam()), hrcRet = hrcCheck);
877 RTPrintf("LowerIPAddress: %ls\n", bstr.raw());
878
879 CHECK_ERROR2I_STMT(svr, COMGETTER(UpperIP)(bstr.asOutParam()), hrcRet = hrcCheck);
880 RTPrintf("UpperIPAddress: %ls\n", bstr.raw());
881
882 CHECK_ERROR2I_STMT(svr, COMGETTER(NetworkMask)(bstr.asOutParam()), hrcRet = hrcCheck);
883 RTPrintf("NetworkMask: %ls\n", bstr.raw());
884
885 BOOL fEnabled = FALSE;
886 CHECK_ERROR2I_STMT(svr, COMGETTER(Enabled)(&fEnabled), hrcRet = hrcCheck);
887 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
888
889 /* Global configuration: */
890 RTPrintf("Global Configuration:\n");
891 HRESULT hrc;
892 ComPtr<IDHCPGlobalConfig> ptrGlobal;
893 CHECK_ERROR2_STMT(hrc, svr, COMGETTER(GlobalConfig)(ptrGlobal.asOutParam()), hrcRet = hrc);
894 if (SUCCEEDED(hrc))
895 {
896 hrc = showDhcpConfig(ptrGlobal);
897 if (FAILED(hrc))
898 hrcRet = hrc;
899 }
900
901 /* Group configurations: */
902 com::SafeIfaceArray<IDHCPGroupConfig> Groups;
903 CHECK_ERROR2_STMT(hrc, svr, COMGETTER(GroupConfigs)(ComSafeArrayAsOutParam(Groups)), hrcRet = hrc);
904 if (FAILED(hrc))
905 RTPrintf("Groups: %Rrc\n", hrc);
906 else if (Groups.size() == 0)
907 RTPrintf("Groups: None\n");
908 else
909 {
910 for (size_t iGrp = 0; iGrp < Groups.size(); iGrp++)
911 {
912 CHECK_ERROR2I_STMT(Groups[iGrp], COMGETTER(Name)(bstr.asOutParam()), hrcRet = hrcCheck);
913 RTPrintf("Group: %ls\n", bstr.raw());
914
915 hrc = showDhcpConfig(Groups[iGrp]);
916 if (FAILED(hrc))
917 hrcRet = hrc;
918 }
919 Groups.setNull();
920 }
921
922 /* Individual host / NIC configurations: */
923 com::SafeIfaceArray<IDHCPIndividualConfig> Hosts;
924 CHECK_ERROR2_STMT(hrc, svr, COMGETTER(IndividualConfigs)(ComSafeArrayAsOutParam(Hosts)), hrcRet = hrc);
925 if (FAILED(hrc))
926 RTPrintf("Individual Configs: %Rrc\n", hrc);
927 else if (Hosts.size() == 0)
928 RTPrintf("Individual Configs: None\n");
929 else
930 {
931 for (size_t iHost = 0; iHost < Hosts.size(); iHost++)
932 {
933 DHCPConfigScope_T enmScope = DHCPConfigScope_MAC;
934 CHECK_ERROR2I_STMT(Hosts[iHost], COMGETTER(Scope)(&enmScope), hrcRet = hrcCheck);
935
936 if (enmScope == DHCPConfigScope_MAC)
937 {
938 CHECK_ERROR2I_STMT(Hosts[i], COMGETTER(MACAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
939 RTPrintf("Individual Config: MAC %ls\n", bstr.raw());
940 }
941 else
942 {
943 ULONG uSlot = 0;
944 CHECK_ERROR2I_STMT(Hosts[i], COMGETTER(Slot)(&uSlot), hrcRet = hrcCheck);
945 CHECK_ERROR2I_STMT(Hosts[i], COMGETTER(MachineId)(bstr.asOutParam()), hrcRet = hrcCheck);
946 Bstr bstrMACAddress;
947 hrc = Hosts[i]->COMGETTER(MACAddress)(bstrMACAddress.asOutParam()); /* No CHECK_ERROR2 stuff! */
948 if (SUCCEEDED(hrc))
949 RTPrintf("Individual Config: VM NIC: %ls slot %u, MAC %ls\n", bstr.raw(), uSlot, bstrMACAddress.raw());
950 else
951 RTPrintf("Individual Config: VM NIC: %ls slot %u, MAC %Rhrc\n", bstr.raw(), uSlot, hrc);
952 }
953
954 CHECK_ERROR2I_STMT(Hosts[i], COMGETTER(FixedAddress)(bstr.asOutParam()), hrcRet = hrcCheck);
955 if (bstr.isNotEmpty())
956 RTPrintf(" Fixed Address: %ls\n", bstr.raw());
957 else
958 RTPrintf(" Fixed Address: dynamic\n");
959
960 hrc = showDhcpConfig(Hosts[i]);
961 if (FAILED(hrc))
962 hrcRet = hrc;
963 }
964 Hosts.setNull();
965 }
966 }
967
968 return hrcRet;
969}
970
971/**
972 * List extension packs.
973 *
974 * @returns See produceList.
975 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
976 */
977static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &pVirtualBox)
978{
979 ComObjPtr<IExtPackManager> ptrExtPackMgr;
980 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
981
982 SafeIfaceArray<IExtPack> extPacks;
983 CHECK_ERROR2I_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
984 RTPrintf("Extension Packs: %u\n", extPacks.size());
985
986 HRESULT hrc = S_OK;
987 for (size_t i = 0; i < extPacks.size(); i++)
988 {
989 /* Read all the properties. */
990 Bstr bstrName;
991 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
992 Bstr bstrDesc;
993 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
994 Bstr bstrVersion;
995 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
996 ULONG uRevision;
997 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
998 Bstr bstrEdition;
999 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Edition)(bstrEdition.asOutParam()), hrc = hrcCheck; bstrEdition.setNull());
1000 Bstr bstrVrdeModule;
1001 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
1002 BOOL fUsable;
1003 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
1004 Bstr bstrWhy;
1005 CHECK_ERROR2I_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
1006
1007 /* Display them. */
1008 if (i)
1009 RTPrintf("\n");
1010 RTPrintf("Pack no.%2zu: %ls\n"
1011 "Version: %ls\n"
1012 "Revision: %u\n"
1013 "Edition: %ls\n"
1014 "Description: %ls\n"
1015 "VRDE Module: %ls\n"
1016 "Usable: %RTbool\n"
1017 "Why unusable: %ls\n",
1018 i, bstrName.raw(),
1019 bstrVersion.raw(),
1020 uRevision,
1021 bstrEdition.raw(),
1022 bstrDesc.raw(),
1023 bstrVrdeModule.raw(),
1024 fUsable != FALSE,
1025 bstrWhy.raw());
1026
1027 /* Query plugins and display them. */
1028 }
1029 return hrc;
1030}
1031
1032
1033/**
1034 * List machine groups.
1035 *
1036 * @returns See produceList.
1037 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1038 */
1039static HRESULT listGroups(const ComPtr<IVirtualBox> &pVirtualBox)
1040{
1041 SafeArray<BSTR> groups;
1042 CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(MachineGroups)(ComSafeArrayAsOutParam(groups)), hrcCheck);
1043
1044 for (size_t i = 0; i < groups.size(); i++)
1045 {
1046 RTPrintf("\"%ls\"\n", groups[i]);
1047 }
1048 return S_OK;
1049}
1050
1051
1052/**
1053 * List video capture devices.
1054 *
1055 * @returns See produceList.
1056 * @param pVirtualBox Reference to the IVirtualBox pointer.
1057 */
1058static HRESULT listVideoInputDevices(const ComPtr<IVirtualBox> pVirtualBox)
1059{
1060 HRESULT rc;
1061 ComPtr<IHost> host;
1062 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1063 com::SafeIfaceArray<IHostVideoInputDevice> hostVideoInputDevices;
1064 CHECK_ERROR(host, COMGETTER(VideoInputDevices)(ComSafeArrayAsOutParam(hostVideoInputDevices)));
1065 RTPrintf("Video Input Devices: %u\n", hostVideoInputDevices.size());
1066 for (size_t i = 0; i < hostVideoInputDevices.size(); ++i)
1067 {
1068 ComPtr<IHostVideoInputDevice> p = hostVideoInputDevices[i];
1069 Bstr name;
1070 p->COMGETTER(Name)(name.asOutParam());
1071 Bstr path;
1072 p->COMGETTER(Path)(path.asOutParam());
1073 Bstr alias;
1074 p->COMGETTER(Alias)(alias.asOutParam());
1075 RTPrintf("%ls \"%ls\"\n%ls\n", alias.raw(), name.raw(), path.raw());
1076 }
1077 return rc;
1078}
1079
1080/**
1081 * List supported screen shot formats.
1082 *
1083 * @returns See produceList.
1084 * @param pVirtualBox Reference to the IVirtualBox pointer.
1085 */
1086static HRESULT listScreenShotFormats(const ComPtr<IVirtualBox> pVirtualBox)
1087{
1088 HRESULT rc = S_OK;
1089 ComPtr<ISystemProperties> systemProperties;
1090 CHECK_ERROR(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
1091 com::SafeArray<BitmapFormat_T> formats;
1092 CHECK_ERROR(systemProperties, COMGETTER(ScreenShotFormats)(ComSafeArrayAsOutParam(formats)));
1093
1094 RTPrintf("Supported %d screen shot formats:\n", formats.size());
1095 for (size_t i = 0; i < formats.size(); ++i)
1096 {
1097 uint32_t u32Format = (uint32_t)formats[i];
1098 char szFormat[5];
1099 szFormat[0] = RT_BYTE1(u32Format);
1100 szFormat[1] = RT_BYTE2(u32Format);
1101 szFormat[2] = RT_BYTE3(u32Format);
1102 szFormat[3] = RT_BYTE4(u32Format);
1103 szFormat[4] = 0;
1104 RTPrintf(" BitmapFormat_%s (0x%08X)\n", szFormat, u32Format);
1105 }
1106 return rc;
1107}
1108
1109/**
1110 * List available cloud providers.
1111 *
1112 * @returns See produceList.
1113 * @param pVirtualBox Reference to the IVirtualBox pointer.
1114 */
1115static HRESULT listCloudProviders(const ComPtr<IVirtualBox> pVirtualBox)
1116{
1117 HRESULT rc = S_OK;
1118 ComPtr<ICloudProviderManager> pCloudProviderManager;
1119 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1120 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1121 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1122
1123 RTPrintf("Supported %d cloud providers:\n", apCloudProviders.size());
1124 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1125 {
1126 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1127 Bstr bstrProviderName;
1128 pCloudProvider->COMGETTER(Name)(bstrProviderName.asOutParam());
1129 RTPrintf("Name: %ls\n", bstrProviderName.raw());
1130 pCloudProvider->COMGETTER(ShortName)(bstrProviderName.asOutParam());
1131 RTPrintf("Short Name: %ls\n", bstrProviderName.raw());
1132 Bstr bstrProviderID;
1133 pCloudProvider->COMGETTER(Id)(bstrProviderID.asOutParam());
1134 RTPrintf("GUID: %ls\n", bstrProviderID.raw());
1135
1136 RTPrintf("\n");
1137 }
1138 return rc;
1139}
1140
1141
1142/**
1143 * List all available cloud profiles (by iterating over the cloud providers).
1144 *
1145 * @returns See produceList.
1146 * @param pVirtualBox Reference to the IVirtualBox pointer.
1147 * @param fOptLong If true, list all profile properties.
1148 */
1149static HRESULT listCloudProfiles(const ComPtr<IVirtualBox> pVirtualBox, bool fOptLong)
1150{
1151 HRESULT rc = S_OK;
1152 ComPtr<ICloudProviderManager> pCloudProviderManager;
1153 CHECK_ERROR(pVirtualBox, COMGETTER(CloudProviderManager)(pCloudProviderManager.asOutParam()));
1154 com::SafeIfaceArray<ICloudProvider> apCloudProviders;
1155 CHECK_ERROR(pCloudProviderManager, COMGETTER(Providers)(ComSafeArrayAsOutParam(apCloudProviders)));
1156
1157 for (size_t i = 0; i < apCloudProviders.size(); ++i)
1158 {
1159 ComPtr<ICloudProvider> pCloudProvider = apCloudProviders[i];
1160 com::SafeIfaceArray<ICloudProfile> apCloudProfiles;
1161 CHECK_ERROR(pCloudProvider, COMGETTER(Profiles)(ComSafeArrayAsOutParam(apCloudProfiles)));
1162 for (size_t j = 0; j < apCloudProfiles.size(); ++j)
1163 {
1164 ComPtr<ICloudProfile> pCloudProfile = apCloudProfiles[j];
1165 Bstr bstrProfileName;
1166 pCloudProfile->COMGETTER(Name)(bstrProfileName.asOutParam());
1167 RTPrintf("Name: %ls\n", bstrProfileName.raw());
1168 Bstr bstrProviderID;
1169 pCloudProfile->COMGETTER(ProviderId)(bstrProviderID.asOutParam());
1170 RTPrintf("Provider GUID: %ls\n", bstrProviderID.raw());
1171
1172 if (fOptLong)
1173 {
1174 com::SafeArray<BSTR> names;
1175 com::SafeArray<BSTR> values;
1176 pCloudProfile->GetProperties(Bstr().raw(), ComSafeArrayAsOutParam(names), ComSafeArrayAsOutParam(values));
1177 size_t cNames = names.size();
1178 size_t cValues = values.size();
1179 bool fFirst = true;
1180 for (size_t k = 0; k < cNames; k++)
1181 {
1182 Bstr value;
1183 if (k < cValues)
1184 value = values[k];
1185 RTPrintf("%s%ls=%ls\n",
1186 fFirst ? "Property: " : " ",
1187 names[k], value.raw());
1188 fFirst = false;
1189 }
1190 }
1191
1192 RTPrintf("\n");
1193 }
1194 }
1195 return rc;
1196}
1197
1198
1199/**
1200 * The type of lists we can produce.
1201 */
1202enum enmListType
1203{
1204 kListNotSpecified = 1000,
1205 kListVMs,
1206 kListRunningVMs,
1207 kListOsTypes,
1208 kListHostDvds,
1209 kListHostFloppies,
1210 kListInternalNetworks,
1211 kListBridgedInterfaces,
1212#if defined(VBOX_WITH_NETFLT)
1213 kListHostOnlyInterfaces,
1214#endif
1215 kListHostCpuIDs,
1216 kListHostInfo,
1217 kListHddBackends,
1218 kListHdds,
1219 kListDvds,
1220 kListFloppies,
1221 kListUsbHost,
1222 kListUsbFilters,
1223 kListSystemProperties,
1224 kListDhcpServers,
1225 kListExtPacks,
1226 kListGroups,
1227 kListNatNetworks,
1228 kListVideoInputDevices,
1229 kListScreenShotFormats,
1230 kListCloudProviders,
1231 kListCloudProfiles,
1232};
1233
1234
1235/**
1236 * Produces the specified listing.
1237 *
1238 * @returns S_OK or some COM error code that has been reported in full.
1239 * @param enmList The list to produce.
1240 * @param fOptLong Long (@c true) or short list format.
1241 * @param pVirtualBox Reference to the IVirtualBox smart pointer.
1242 */
1243static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, bool fOptSorted, const ComPtr<IVirtualBox> &pVirtualBox)
1244{
1245 HRESULT rc = S_OK;
1246 switch (enmCommand)
1247 {
1248 case kListNotSpecified:
1249 AssertFailed();
1250 return E_FAIL;
1251
1252 case kListVMs:
1253 {
1254 /*
1255 * Get the list of all registered VMs
1256 */
1257 com::SafeIfaceArray<IMachine> machines;
1258 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1259 if (SUCCEEDED(rc))
1260 {
1261 /*
1262 * Display it.
1263 */
1264 if (!fOptSorted)
1265 {
1266 for (size_t i = 0; i < machines.size(); ++i)
1267 if (machines[i])
1268 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1269 }
1270 else
1271 {
1272 /*
1273 * Sort the list by name before displaying it.
1274 */
1275 std::vector<std::pair<com::Bstr, IMachine *> > sortedMachines;
1276 for (size_t i = 0; i < machines.size(); ++i)
1277 {
1278 IMachine *pMachine = machines[i];
1279 if (pMachine) /* no idea why we need to do this... */
1280 {
1281 Bstr bstrName;
1282 pMachine->COMGETTER(Name)(bstrName.asOutParam());
1283 sortedMachines.push_back(std::pair<com::Bstr, IMachine *>(bstrName, pMachine));
1284 }
1285 }
1286
1287 std::sort(sortedMachines.begin(), sortedMachines.end());
1288
1289 for (size_t i = 0; i < sortedMachines.size(); ++i)
1290 rc = showVMInfo(pVirtualBox, sortedMachines[i].second, NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1291 }
1292 }
1293 break;
1294 }
1295
1296 case kListRunningVMs:
1297 {
1298 /*
1299 * Get the list of all _running_ VMs
1300 */
1301 com::SafeIfaceArray<IMachine> machines;
1302 rc = pVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
1303 com::SafeArray<MachineState_T> states;
1304 if (SUCCEEDED(rc))
1305 rc = pVirtualBox->GetMachineStates(ComSafeArrayAsInParam(machines), ComSafeArrayAsOutParam(states));
1306 if (SUCCEEDED(rc))
1307 {
1308 /*
1309 * Iterate through the collection
1310 */
1311 for (size_t i = 0; i < machines.size(); ++i)
1312 {
1313 if (machines[i])
1314 {
1315 MachineState_T machineState = states[i];
1316 switch (machineState)
1317 {
1318 case MachineState_Running:
1319 case MachineState_Teleporting:
1320 case MachineState_LiveSnapshotting:
1321 case MachineState_Paused:
1322 case MachineState_TeleportingPausedVM:
1323 rc = showVMInfo(pVirtualBox, machines[i], NULL, fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
1324 break;
1325 default: break; /* Shut up MSC */
1326 }
1327 }
1328 }
1329 }
1330 break;
1331 }
1332
1333 case kListOsTypes:
1334 {
1335 com::SafeIfaceArray<IGuestOSType> coll;
1336 rc = pVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
1337 if (SUCCEEDED(rc))
1338 {
1339 /*
1340 * Iterate through the collection.
1341 */
1342 for (size_t i = 0; i < coll.size(); ++i)
1343 {
1344 ComPtr<IGuestOSType> guestOS;
1345 guestOS = coll[i];
1346 Bstr guestId;
1347 guestOS->COMGETTER(Id)(guestId.asOutParam());
1348 RTPrintf("ID: %ls\n", guestId.raw());
1349 Bstr guestDescription;
1350 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
1351 RTPrintf("Description: %ls\n", guestDescription.raw());
1352 Bstr familyId;
1353 guestOS->COMGETTER(FamilyId)(familyId.asOutParam());
1354 RTPrintf("Family ID: %ls\n", familyId.raw());
1355 Bstr familyDescription;
1356 guestOS->COMGETTER(FamilyDescription)(familyDescription.asOutParam());
1357 RTPrintf("Family Desc: %ls\n", familyDescription.raw());
1358 BOOL is64Bit;
1359 guestOS->COMGETTER(Is64Bit)(&is64Bit);
1360 RTPrintf("64 bit: %RTbool\n", is64Bit);
1361 RTPrintf("\n");
1362 }
1363 }
1364 break;
1365 }
1366
1367 case kListHostDvds:
1368 {
1369 ComPtr<IHost> host;
1370 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1371 com::SafeIfaceArray<IMedium> coll;
1372 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
1373 if (SUCCEEDED(rc))
1374 {
1375 for (size_t i = 0; i < coll.size(); ++i)
1376 {
1377 ComPtr<IMedium> dvdDrive = coll[i];
1378 Bstr uuid;
1379 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
1380 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1381 Bstr location;
1382 dvdDrive->COMGETTER(Location)(location.asOutParam());
1383 RTPrintf("Name: %ls\n\n", location.raw());
1384 }
1385 }
1386 break;
1387 }
1388
1389 case kListHostFloppies:
1390 {
1391 ComPtr<IHost> host;
1392 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(host.asOutParam()));
1393 com::SafeIfaceArray<IMedium> coll;
1394 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
1395 if (SUCCEEDED(rc))
1396 {
1397 for (size_t i = 0; i < coll.size(); ++i)
1398 {
1399 ComPtr<IMedium> floppyDrive = coll[i];
1400 Bstr uuid;
1401 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
1402 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
1403 Bstr location;
1404 floppyDrive->COMGETTER(Location)(location.asOutParam());
1405 RTPrintf("Name: %ls\n\n", location.raw());
1406 }
1407 }
1408 break;
1409 }
1410
1411 case kListInternalNetworks:
1412 rc = listInternalNetworks(pVirtualBox);
1413 break;
1414
1415 case kListBridgedInterfaces:
1416#if defined(VBOX_WITH_NETFLT)
1417 case kListHostOnlyInterfaces:
1418#endif
1419 rc = listNetworkInterfaces(pVirtualBox, enmCommand == kListBridgedInterfaces);
1420 break;
1421
1422 case kListHostInfo:
1423 rc = listHostInfo(pVirtualBox);
1424 break;
1425
1426 case kListHostCpuIDs:
1427 {
1428 ComPtr<IHost> Host;
1429 CHECK_ERROR(pVirtualBox, COMGETTER(Host)(Host.asOutParam()));
1430
1431 RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
1432 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
1433 static uint32_t const s_auCpuIdRanges[] =
1434 {
1435 UINT32_C(0x00000000), UINT32_C(0x0000007f),
1436 UINT32_C(0x80000000), UINT32_C(0x8000007f),
1437 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
1438 };
1439 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
1440 {
1441 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
1442 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
1443 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
1444 continue;
1445 cLeafs++;
1446 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
1447 {
1448 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
1449 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
1450 }
1451 }
1452 break;
1453 }
1454
1455 case kListHddBackends:
1456 rc = listHddBackends(pVirtualBox);
1457 break;
1458
1459 case kListHdds:
1460 {
1461 com::SafeIfaceArray<IMedium> hdds;
1462 CHECK_ERROR(pVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
1463 rc = listMedia(pVirtualBox, hdds, "base", fOptLong);
1464 break;
1465 }
1466
1467 case kListDvds:
1468 {
1469 com::SafeIfaceArray<IMedium> dvds;
1470 CHECK_ERROR(pVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
1471 rc = listMedia(pVirtualBox, dvds, NULL, fOptLong);
1472 break;
1473 }
1474
1475 case kListFloppies:
1476 {
1477 com::SafeIfaceArray<IMedium> floppies;
1478 CHECK_ERROR(pVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
1479 rc = listMedia(pVirtualBox, floppies, NULL, fOptLong);
1480 break;
1481 }
1482
1483 case kListUsbHost:
1484 rc = listUsbHost(pVirtualBox);
1485 break;
1486
1487 case kListUsbFilters:
1488 rc = listUsbFilters(pVirtualBox);
1489 break;
1490
1491 case kListSystemProperties:
1492 rc = listSystemProperties(pVirtualBox);
1493 break;
1494
1495 case kListDhcpServers:
1496 rc = listDhcpServers(pVirtualBox);
1497 break;
1498
1499 case kListExtPacks:
1500 rc = listExtensionPacks(pVirtualBox);
1501 break;
1502
1503 case kListGroups:
1504 rc = listGroups(pVirtualBox);
1505 break;
1506
1507 case kListNatNetworks:
1508 {
1509 com::SafeIfaceArray<INATNetwork> nets;
1510 CHECK_ERROR(pVirtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(nets)));
1511 for (size_t i = 0; i < nets.size(); ++i)
1512 {
1513 ComPtr<INATNetwork> net = nets[i];
1514 Bstr netName;
1515 net->COMGETTER(NetworkName)(netName.asOutParam());
1516 RTPrintf("NetworkName: %ls\n", netName.raw());
1517 Bstr gateway;
1518 net->COMGETTER(Gateway)(gateway.asOutParam());
1519 RTPrintf("IP: %ls\n", gateway.raw());
1520 Bstr network;
1521 net->COMGETTER(Network)(network.asOutParam());
1522 RTPrintf("Network: %ls\n", network.raw());
1523 BOOL fEnabled;
1524 net->COMGETTER(IPv6Enabled)(&fEnabled);
1525 RTPrintf("IPv6 Enabled: %s\n", fEnabled ? "Yes" : "No");
1526 Bstr ipv6prefix;
1527 net->COMGETTER(IPv6Prefix)(ipv6prefix.asOutParam());
1528 RTPrintf("IPv6 Prefix: %ls\n", ipv6prefix.raw());
1529 net->COMGETTER(NeedDhcpServer)(&fEnabled);
1530 RTPrintf("DHCP Enabled: %s\n", fEnabled ? "Yes" : "No");
1531 net->COMGETTER(Enabled)(&fEnabled);
1532 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
1533
1534#define PRINT_STRING_ARRAY(title) \
1535 if (strs.size() > 0) \
1536 { \
1537 RTPrintf(title); \
1538 size_t j = 0; \
1539 for (;j < strs.size(); ++j) \
1540 RTPrintf(" %s\n", Utf8Str(strs[j]).c_str()); \
1541 }
1542
1543 com::SafeArray<BSTR> strs;
1544
1545 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules4)(ComSafeArrayAsOutParam(strs)));
1546 PRINT_STRING_ARRAY("Port-forwarding (ipv4)\n");
1547 strs.setNull();
1548
1549 CHECK_ERROR(nets[i], COMGETTER(PortForwardRules6)(ComSafeArrayAsOutParam(strs)));
1550 PRINT_STRING_ARRAY("Port-forwarding (ipv6)\n");
1551 strs.setNull();
1552
1553 CHECK_ERROR(nets[i], COMGETTER(LocalMappings)(ComSafeArrayAsOutParam(strs)));
1554 PRINT_STRING_ARRAY("loopback mappings (ipv4)\n");
1555 strs.setNull();
1556
1557#undef PRINT_STRING_ARRAY
1558 RTPrintf("\n");
1559 }
1560 break;
1561 }
1562
1563 case kListVideoInputDevices:
1564 rc = listVideoInputDevices(pVirtualBox);
1565 break;
1566
1567 case kListScreenShotFormats:
1568 rc = listScreenShotFormats(pVirtualBox);
1569 break;
1570
1571 case kListCloudProviders:
1572 rc = listCloudProviders(pVirtualBox);
1573 break;
1574
1575 case kListCloudProfiles:
1576 rc = listCloudProfiles(pVirtualBox, fOptLong);
1577 break;
1578
1579 /* No default here, want gcc warnings. */
1580
1581 } /* end switch */
1582
1583 return rc;
1584}
1585
1586/**
1587 * Handles the 'list' command.
1588 *
1589 * @returns Appropriate exit code.
1590 * @param a Handler argument.
1591 */
1592RTEXITCODE handleList(HandlerArg *a)
1593{
1594 bool fOptLong = false;
1595 bool fOptMultiple = false;
1596 bool fOptSorted = false;
1597 enum enmListType enmOptCommand = kListNotSpecified;
1598
1599 static const RTGETOPTDEF s_aListOptions[] =
1600 {
1601 { "--long", 'l', RTGETOPT_REQ_NOTHING },
1602 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
1603 { "--sorted", 's', RTGETOPT_REQ_NOTHING },
1604 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
1605 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
1606 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
1607 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
1608 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
1609 { "intnets", kListInternalNetworks, RTGETOPT_REQ_NOTHING },
1610 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
1611 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
1612#if defined(VBOX_WITH_NETFLT)
1613 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
1614#endif
1615 { "natnetworks", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1616 { "natnets", kListNatNetworks, RTGETOPT_REQ_NOTHING },
1617 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
1618 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
1619 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
1620 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
1621 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
1622 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
1623 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
1624 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
1625 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
1626 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
1627 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
1628 { "groups", kListGroups, RTGETOPT_REQ_NOTHING },
1629 { "webcams", kListVideoInputDevices, RTGETOPT_REQ_NOTHING },
1630 { "screenshotformats", kListScreenShotFormats, RTGETOPT_REQ_NOTHING },
1631 { "cloudproviders", kListCloudProviders, RTGETOPT_REQ_NOTHING },
1632 { "cloudprofiles", kListCloudProfiles, RTGETOPT_REQ_NOTHING },
1633 };
1634
1635 int ch;
1636 RTGETOPTUNION ValueUnion;
1637 RTGETOPTSTATE GetState;
1638 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
1639 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
1640 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1641 {
1642 switch (ch)
1643 {
1644 case 'l': /* --long */
1645 fOptLong = true;
1646 break;
1647
1648 case 's':
1649 fOptSorted = true;
1650 break;
1651
1652 case 'm':
1653 fOptMultiple = true;
1654 if (enmOptCommand == kListNotSpecified)
1655 break;
1656 ch = enmOptCommand;
1657 RT_FALL_THRU();
1658
1659 case kListVMs:
1660 case kListRunningVMs:
1661 case kListOsTypes:
1662 case kListHostDvds:
1663 case kListHostFloppies:
1664 case kListInternalNetworks:
1665 case kListBridgedInterfaces:
1666#if defined(VBOX_WITH_NETFLT)
1667 case kListHostOnlyInterfaces:
1668#endif
1669 case kListHostInfo:
1670 case kListHostCpuIDs:
1671 case kListHddBackends:
1672 case kListHdds:
1673 case kListDvds:
1674 case kListFloppies:
1675 case kListUsbHost:
1676 case kListUsbFilters:
1677 case kListSystemProperties:
1678 case kListDhcpServers:
1679 case kListExtPacks:
1680 case kListGroups:
1681 case kListNatNetworks:
1682 case kListVideoInputDevices:
1683 case kListScreenShotFormats:
1684 case kListCloudProviders:
1685 case kListCloudProfiles:
1686 enmOptCommand = (enum enmListType)ch;
1687 if (fOptMultiple)
1688 {
1689 HRESULT hrc = produceList((enum enmListType)ch, fOptLong, fOptSorted, a->virtualBox);
1690 if (FAILED(hrc))
1691 return RTEXITCODE_FAILURE;
1692 }
1693 break;
1694
1695 case VINF_GETOPT_NOT_OPTION:
1696 return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
1697
1698 default:
1699 return errorGetOpt(USAGE_LIST, ch, &ValueUnion);
1700 }
1701 }
1702
1703 /*
1704 * If not in multiple list mode, we have to produce the list now.
1705 */
1706 if (enmOptCommand == kListNotSpecified)
1707 return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
1708 if (!fOptMultiple)
1709 {
1710 HRESULT hrc = produceList(enmOptCommand, fOptLong, fOptSorted, a->virtualBox);
1711 if (FAILED(hrc))
1712 return RTEXITCODE_FAILURE;
1713 }
1714
1715 return RTEXITCODE_SUCCESS;
1716}
1717
1718#endif /* !VBOX_ONLY_DOCS */
1719/* 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