VirtualBox

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

Last change on this file since 35273 was 35085, checked in by vboxsync, 13 years ago

VBoxManage: add support for readonly/multiattach media types
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 44.3 KB
Line 
1/* $Id: VBoxManageList.cpp 35085 2010-12-14 14:09:12Z vboxsync $ */
2/** @file
3 * VBoxManage - The 'list' command.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.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* Header Files *
22*******************************************************************************/
23#include <VBox/com/com.h>
24#include <VBox/com/string.h>
25#include <VBox/com/Guid.h>
26#include <VBox/com/array.h>
27#include <VBox/com/ErrorInfo.h>
28#include <VBox/com/errorprint.h>
29
30#include <VBox/com/VirtualBox.h>
31
32#include <VBox/log.h>
33#include <iprt/stream.h>
34#include <iprt/string.h>
35#include <iprt/time.h>
36#include <iprt/getopt.h>
37#include <iprt/ctype.h>
38
39#include "VBoxManage.h"
40using namespace com;
41
42#ifdef VBOX_WITH_HOSTNETIF_API
43static const char *getHostIfMediumTypeText(HostNetworkInterfaceMediumType_T enmType)
44{
45 switch (enmType)
46 {
47 case HostNetworkInterfaceMediumType_Ethernet: return "Ethernet";
48 case HostNetworkInterfaceMediumType_PPP: return "PPP";
49 case HostNetworkInterfaceMediumType_SLIP: return "SLIP";
50 }
51 return "Unknown";
52}
53
54static const char *getHostIfStatusText(HostNetworkInterfaceStatus_T enmStatus)
55{
56 switch (enmStatus)
57 {
58 case HostNetworkInterfaceStatus_Up: return "Up";
59 case HostNetworkInterfaceStatus_Down: return "Down";
60 }
61 return "Unknown";
62}
63#endif /* VBOX_WITH_HOSTNETIF_API */
64
65static const char*getDeviceTypeText(DeviceType_T enmType)
66{
67 switch (enmType)
68 {
69 case DeviceType_HardDisk: return "HardDisk";
70 case DeviceType_DVD: return "DVD";
71 case DeviceType_Floppy: return "Floppy";
72 }
73 return "Unknown";
74}
75
76static void listMedia(const ComPtr<IVirtualBox> aVirtualBox,
77 const com::SafeIfaceArray<IMedium> &aMedia,
78 const char *pszParentUUIDStr)
79{
80 HRESULT rc;
81 for (size_t i = 0; i < aMedia.size(); ++i)
82 {
83 ComPtr<IMedium> pMedium = aMedia[i];
84 Bstr uuid;
85 pMedium->COMGETTER(Id)(uuid.asOutParam());
86 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
87 if (pszParentUUIDStr)
88 RTPrintf("Parent UUID: %s\n", pszParentUUIDStr);
89 Bstr format;
90 pMedium->COMGETTER(Format)(format.asOutParam());
91 RTPrintf("Format: %lS\n", format.raw());
92 Bstr filepath;
93 pMedium->COMGETTER(Location)(filepath.asOutParam());
94 RTPrintf("Location: %lS\n", filepath.raw());
95
96 MediumState_T enmState;
97 pMedium->RefreshState(&enmState);
98 const char *stateStr = "unknown";
99 switch (enmState)
100 {
101 case MediumState_NotCreated:
102 stateStr = "not created";
103 break;
104 case MediumState_Created:
105 stateStr = "created";
106 break;
107 case MediumState_LockedRead:
108 stateStr = "locked read";
109 break;
110 case MediumState_LockedWrite:
111 stateStr = "locked write";
112 break;
113 case MediumState_Inaccessible:
114 stateStr = "inaccessible";
115 break;
116 case MediumState_Creating:
117 stateStr = "creating";
118 break;
119 case MediumState_Deleting:
120 stateStr = "deleting";
121 break;
122 }
123 RTPrintf("State: %s\n", stateStr);
124
125 MediumType_T type;
126 pMedium->COMGETTER(Type)(&type);
127 const char *typeStr = "unknown";
128 switch (type)
129 {
130 case MediumType_Normal:
131 typeStr = "normal";
132 break;
133 case MediumType_Immutable:
134 typeStr = "immutable";
135 break;
136 case MediumType_Writethrough:
137 typeStr = "writethrough";
138 break;
139 case MediumType_Shareable:
140 typeStr = "shareable";
141 break;
142 case MediumType_Readonly:
143 typeStr = "readonly";
144 break;
145 case MediumType_MultiAttach:
146 typeStr = "multiattach";
147 break;
148 }
149 RTPrintf("Type: %s\n", typeStr);
150
151 com::SafeArray<BSTR> machineIds;
152 pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(machineIds));
153 for (size_t j = 0; j < machineIds.size(); ++j)
154 {
155 ComPtr<IMachine> machine;
156 CHECK_ERROR(aVirtualBox, FindMachine(machineIds[j], machine.asOutParam()));
157 ASSERT(machine);
158 Bstr name;
159 machine->COMGETTER(Name)(name.asOutParam());
160 RTPrintf("%s%lS (UUID: %lS)",
161 j == 0 ? "Usage: " : " ",
162 name.raw(), machineIds[j]);
163 com::SafeArray<BSTR> snapshotIds;
164 pMedium->GetSnapshotIds(machineIds[j],
165 ComSafeArrayAsOutParam(snapshotIds));
166 for (size_t k = 0; k < snapshotIds.size(); ++k)
167 {
168 ComPtr<ISnapshot> snapshot;
169 machine->FindSnapshot(snapshotIds[k], snapshot.asOutParam());
170 if (snapshot)
171 {
172 Bstr snapshotName;
173 snapshot->COMGETTER(Name)(snapshotName.asOutParam());
174 RTPrintf(" [%lS (UUID: %lS)]", snapshotName.raw(), snapshotIds[k]);
175 }
176 }
177 RTPrintf("\n");
178 }
179 RTPrintf("\n");
180
181 com::SafeIfaceArray<IMedium> children;
182 CHECK_ERROR(pMedium, COMGETTER(Children)(ComSafeArrayAsOutParam(children)));
183 if (children.size() > 0)
184 {
185 // depth first listing of child media
186 listMedia(aVirtualBox, children, Utf8Str(uuid).c_str());
187 }
188 }
189}
190
191
192/**
193 * List extension packs.
194 *
195 * @returns See produceList.
196 * @param rptrVirtualBox Reference to the IVirtualBox smart pointer.
197 */
198static HRESULT listExtensionPacks(const ComPtr<IVirtualBox> &rptrVirtualBox)
199{
200 ComObjPtr<IExtPackManager> ptrExtPackMgr;
201 CHECK_ERROR2_RET(rptrVirtualBox, COMGETTER(ExtensionPackManager)(ptrExtPackMgr.asOutParam()), hrcCheck);
202
203 SafeIfaceArray<IExtPack> extPacks;
204 CHECK_ERROR2_RET(ptrExtPackMgr, COMGETTER(InstalledExtPacks)(ComSafeArrayAsOutParam(extPacks)), hrcCheck);
205 RTPrintf("Extension Packs: %u\n", extPacks.size());
206
207 HRESULT hrc = S_OK;
208 for (size_t i = 0; i < extPacks.size(); i++)
209 {
210 /* Read all the properties. */
211 Bstr bstrName;
212 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(Name)(bstrName.asOutParam()), hrc = hrcCheck; bstrName.setNull());
213 Bstr bstrDesc;
214 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(Description)(bstrDesc.asOutParam()), hrc = hrcCheck; bstrDesc.setNull());
215 Bstr bstrVersion;
216 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(Version)(bstrVersion.asOutParam()), hrc = hrcCheck; bstrVersion.setNull());
217 ULONG uRevision;
218 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(Revision)(&uRevision), hrc = hrcCheck; uRevision = 0);
219 Bstr bstrVrdeModule;
220 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(VRDEModule)(bstrVrdeModule.asOutParam()),hrc=hrcCheck; bstrVrdeModule.setNull());
221 BOOL fUsable;
222 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(Usable)(&fUsable), hrc = hrcCheck; fUsable = FALSE);
223 Bstr bstrWhy;
224 CHECK_ERROR2_STMT(extPacks[i], COMGETTER(WhyUnusable)(bstrWhy.asOutParam()), hrc = hrcCheck; bstrWhy.setNull());
225
226 /* Display them. */
227 if (i)
228 RTPrintf("\n");
229 RTPrintf("Pack no.%2zu: %lS\n"
230 "Version: %lS\n"
231 "Revision: %u\n"
232 "Description: %lS\n"
233 "VRDE Module: %lS\n"
234 "Usable: %RTbool\n"
235 "Why unusable: %lS\n",
236 i, bstrName.raw(),
237 bstrVersion.raw(),
238 uRevision,
239 bstrDesc.raw(),
240 bstrVrdeModule.raw(),
241 fUsable != FALSE,
242 bstrWhy.raw());
243
244 /* Query plugins and display them. */
245 }
246 return hrc;
247}
248
249
250/**
251 * The type of lists we can produce.
252 */
253enum enmListType
254{
255 kListNotSpecified = 1000,
256 kListVMs,
257 kListRunningVMs,
258 kListOsTypes,
259 kListHostDvds,
260 kListHostFloppies,
261 kListBridgedInterfaces,
262#if defined(VBOX_WITH_NETFLT)
263 kListHostOnlyInterfaces,
264#endif
265 kListHostCpuIDs,
266 kListHostInfo,
267 kListHddBackends,
268 kListHdds,
269 kListDvds,
270 kListFloppies,
271 kListUsbHost,
272 kListUsbFilters,
273 kListSystemProperties,
274 kListDhcpServers,
275 kListExtPacks
276};
277
278
279/**
280 * Produces the specified listing.
281 *
282 * @returns S_OK or some COM error code that has been reported in full.
283 * @param enmList The list to produce.
284 * @param fOptLong Long (@c true) or short list format.
285 * @param rptrVirtualBox Reference to the IVirtualBox smart pointer.
286 */
287static HRESULT produceList(enum enmListType enmCommand, bool fOptLong, const ComPtr<IVirtualBox> &rptrVirtualBox)
288{
289 HRESULT rc = S_OK;
290 switch (enmCommand)
291 {
292 case kListNotSpecified:
293 AssertFailed();
294 return E_FAIL;
295
296 case kListVMs:
297 {
298 /*
299 * Get the list of all registered VMs
300 */
301 com::SafeIfaceArray<IMachine> machines;
302 rc = rptrVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
303 if (SUCCEEDED(rc))
304 {
305 /*
306 * Iterate through the collection
307 */
308 for (size_t i = 0; i < machines.size(); ++i)
309 {
310 if (machines[i])
311 rc = showVMInfo(rptrVirtualBox, machines[i], fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
312 }
313 }
314 break;
315 }
316
317 case kListRunningVMs:
318 {
319 /*
320 * Get the list of all _running_ VMs
321 */
322 com::SafeIfaceArray<IMachine> machines;
323 rc = rptrVirtualBox->COMGETTER(Machines)(ComSafeArrayAsOutParam(machines));
324 if (SUCCEEDED(rc))
325 {
326 /*
327 * Iterate through the collection
328 */
329 for (size_t i = 0; i < machines.size(); ++i)
330 {
331 if (machines[i])
332 {
333 MachineState_T machineState;
334 rc = machines[i]->COMGETTER(State)(&machineState);
335 if (SUCCEEDED(rc))
336 {
337 switch (machineState)
338 {
339 case MachineState_Running:
340 case MachineState_Teleporting:
341 case MachineState_LiveSnapshotting:
342 case MachineState_Paused:
343 case MachineState_TeleportingPausedVM:
344 rc = showVMInfo(rptrVirtualBox, machines[i], fOptLong ? VMINFO_STANDARD : VMINFO_COMPACT);
345 break;
346 }
347 }
348 }
349 }
350 }
351 break;
352 }
353
354 case kListOsTypes:
355 {
356 com::SafeIfaceArray<IGuestOSType> coll;
357 rc = rptrVirtualBox->COMGETTER(GuestOSTypes)(ComSafeArrayAsOutParam(coll));
358 if (SUCCEEDED(rc))
359 {
360 /*
361 * Iterate through the collection.
362 */
363 for (size_t i = 0; i < coll.size(); ++i)
364 {
365 ComPtr<IGuestOSType> guestOS;
366 guestOS = coll[i];
367 Bstr guestId;
368 guestOS->COMGETTER(Id)(guestId.asOutParam());
369 RTPrintf("ID: %lS\n", guestId.raw());
370 Bstr guestDescription;
371 guestOS->COMGETTER(Description)(guestDescription.asOutParam());
372 RTPrintf("Description: %lS\n\n", guestDescription.raw());
373 }
374 }
375 break;
376 }
377
378 case kListHostDvds:
379 {
380 ComPtr<IHost> host;
381 CHECK_ERROR(rptrVirtualBox, COMGETTER(Host)(host.asOutParam()));
382 com::SafeIfaceArray<IMedium> coll;
383 CHECK_ERROR(host, COMGETTER(DVDDrives)(ComSafeArrayAsOutParam(coll)));
384 if (SUCCEEDED(rc))
385 {
386 for (size_t i = 0; i < coll.size(); ++i)
387 {
388 ComPtr<IMedium> dvdDrive = coll[i];
389 Bstr uuid;
390 dvdDrive->COMGETTER(Id)(uuid.asOutParam());
391 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
392 Bstr name;
393 dvdDrive->COMGETTER(Name)(name.asOutParam());
394 RTPrintf("Name: %lS\n\n", name.raw());
395 }
396 }
397 break;
398 }
399
400 case kListHostFloppies:
401 {
402 ComPtr<IHost> host;
403 CHECK_ERROR(rptrVirtualBox, COMGETTER(Host)(host.asOutParam()));
404 com::SafeIfaceArray<IMedium> coll;
405 CHECK_ERROR(host, COMGETTER(FloppyDrives)(ComSafeArrayAsOutParam(coll)));
406 if (SUCCEEDED(rc))
407 {
408 for (size_t i = 0; i < coll.size(); ++i)
409 {
410 ComPtr<IMedium> floppyDrive = coll[i];
411 Bstr uuid;
412 floppyDrive->COMGETTER(Id)(uuid.asOutParam());
413 RTPrintf("UUID: %s\n", Utf8Str(uuid).c_str());
414 Bstr name;
415 floppyDrive->COMGETTER(Name)(name.asOutParam());
416 RTPrintf("Name: %lS\n\n", name.raw());
417 }
418 }
419 break;
420 }
421
422 /** @todo function. */
423 case kListBridgedInterfaces:
424#if defined(VBOX_WITH_NETFLT)
425 case kListHostOnlyInterfaces:
426#endif
427 {
428 ComPtr<IHost> host;
429 CHECK_ERROR(rptrVirtualBox, COMGETTER(Host)(host.asOutParam()));
430 com::SafeIfaceArray<IHostNetworkInterface> hostNetworkInterfaces;
431#if defined(VBOX_WITH_NETFLT)
432 if (enmCommand == kListBridgedInterfaces)
433 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_Bridged,
434 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
435 else
436 CHECK_ERROR(host, FindHostNetworkInterfacesOfType(HostNetworkInterfaceType_HostOnly,
437 ComSafeArrayAsOutParam(hostNetworkInterfaces)));
438#else
439 CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(ComSafeArrayAsOutParam(hostNetworkInterfaces)));
440#endif
441 for (size_t i = 0; i < hostNetworkInterfaces.size(); ++i)
442 {
443 ComPtr<IHostNetworkInterface> networkInterface = hostNetworkInterfaces[i];
444#ifndef VBOX_WITH_HOSTNETIF_API
445 Bstr interfaceName;
446 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
447 RTPrintf("Name: %lS\n", interfaceName.raw());
448 Guid interfaceGuid;
449 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
450 RTPrintf("GUID: %lS\n\n", Bstr(interfaceGuid.toString()).raw());
451#else /* VBOX_WITH_HOSTNETIF_API */
452 Bstr interfaceName;
453 networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
454 RTPrintf("Name: %lS\n", interfaceName.raw());
455 Bstr interfaceGuid;
456 networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
457 RTPrintf("GUID: %lS\n", interfaceGuid.raw());
458 BOOL bDhcpEnabled;
459 networkInterface->COMGETTER(DhcpEnabled)(&bDhcpEnabled);
460 RTPrintf("Dhcp: %s\n", bDhcpEnabled ? "Enabled" : "Disabled");
461
462 Bstr IPAddress;
463 networkInterface->COMGETTER(IPAddress)(IPAddress.asOutParam());
464 RTPrintf("IPAddress: %lS\n", IPAddress.raw());
465 Bstr NetworkMask;
466 networkInterface->COMGETTER(NetworkMask)(NetworkMask.asOutParam());
467 RTPrintf("NetworkMask: %lS\n", NetworkMask.raw());
468 Bstr IPV6Address;
469 networkInterface->COMGETTER(IPV6Address)(IPV6Address.asOutParam());
470 RTPrintf("IPV6Address: %lS\n", IPV6Address.raw());
471 ULONG IPV6NetworkMaskPrefixLength;
472 networkInterface->COMGETTER(IPV6NetworkMaskPrefixLength)(&IPV6NetworkMaskPrefixLength);
473 RTPrintf("IPV6NetworkMaskPrefixLength: %d\n", IPV6NetworkMaskPrefixLength);
474 Bstr HardwareAddress;
475 networkInterface->COMGETTER(HardwareAddress)(HardwareAddress.asOutParam());
476 RTPrintf("HardwareAddress: %lS\n", HardwareAddress.raw());
477 HostNetworkInterfaceMediumType_T Type;
478 networkInterface->COMGETTER(MediumType)(&Type);
479 RTPrintf("MediumType: %s\n", getHostIfMediumTypeText(Type));
480 HostNetworkInterfaceStatus_T Status;
481 networkInterface->COMGETTER(Status)(&Status);
482 RTPrintf("Status: %s\n", getHostIfStatusText(Status));
483 Bstr netName;
484 networkInterface->COMGETTER(NetworkName)(netName.asOutParam());
485 RTPrintf("VBoxNetworkName: %lS\n\n", netName.raw());
486#endif
487 }
488 break;
489 }
490
491 /** @todo function. */
492 case kListHostInfo:
493 {
494 ComPtr<IHost> Host;
495 CHECK_ERROR(rptrVirtualBox, COMGETTER(Host)(Host.asOutParam()));
496
497 RTPrintf("Host Information:\n\n");
498
499 LONG64 u64UtcTime = 0;
500 CHECK_ERROR(Host, COMGETTER(UTCTime)(&u64UtcTime));
501 RTTIMESPEC timeSpec;
502 char szTime[32];
503 RTPrintf("Host time: %s\n", RTTimeSpecToString(RTTimeSpecSetMilli(&timeSpec, u64UtcTime), szTime, sizeof(szTime)));
504
505 ULONG processorOnlineCount = 0;
506 CHECK_ERROR(Host, COMGETTER(ProcessorOnlineCount)(&processorOnlineCount));
507 RTPrintf("Processor online count: %lu\n", processorOnlineCount);
508 ULONG processorCount = 0;
509 CHECK_ERROR(Host, COMGETTER(ProcessorCount)(&processorCount));
510 RTPrintf("Processor count: %lu\n", processorCount);
511 ULONG processorSpeed = 0;
512 Bstr processorDescription;
513 for (ULONG i = 0; i < processorCount; i++)
514 {
515 CHECK_ERROR(Host, GetProcessorSpeed(i, &processorSpeed));
516 if (processorSpeed)
517 RTPrintf("Processor#%u speed: %lu MHz\n", i, processorSpeed);
518 else
519 RTPrintf("Processor#%u speed: unknown\n", i, processorSpeed);
520 CHECK_ERROR(Host, GetProcessorDescription(i, processorDescription.asOutParam()));
521 RTPrintf("Processor#%u description: %lS\n", i, processorDescription.raw());
522 }
523
524 ULONG memorySize = 0;
525 CHECK_ERROR(Host, COMGETTER(MemorySize)(&memorySize));
526 RTPrintf("Memory size: %lu MByte\n", memorySize);
527
528 ULONG memoryAvailable = 0;
529 CHECK_ERROR(Host, COMGETTER(MemoryAvailable)(&memoryAvailable));
530 RTPrintf("Memory available: %lu MByte\n", memoryAvailable);
531
532 Bstr operatingSystem;
533 CHECK_ERROR(Host, COMGETTER(OperatingSystem)(operatingSystem.asOutParam()));
534 RTPrintf("Operating system: %lS\n", operatingSystem.raw());
535
536 Bstr oSVersion;
537 CHECK_ERROR(Host, COMGETTER(OSVersion)(oSVersion.asOutParam()));
538 RTPrintf("Operating system version: %lS\n", oSVersion.raw());
539 break;
540 }
541
542 case kListHostCpuIDs:
543 {
544 ComPtr<IHost> Host;
545 CHECK_ERROR(rptrVirtualBox, COMGETTER(Host)(Host.asOutParam()));
546
547 RTPrintf("Host CPUIDs:\n\nLeaf no. EAX EBX ECX EDX\n");
548 ULONG uCpuNo = 0; /* ASSUMES that CPU#0 is online. */
549 static uint32_t const s_auCpuIdRanges[] =
550 {
551 UINT32_C(0x00000000), UINT32_C(0x0000007f),
552 UINT32_C(0x80000000), UINT32_C(0x8000007f),
553 UINT32_C(0xc0000000), UINT32_C(0xc000007f)
554 };
555 for (unsigned i = 0; i < RT_ELEMENTS(s_auCpuIdRanges); i += 2)
556 {
557 ULONG uEAX, uEBX, uECX, uEDX, cLeafs;
558 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, s_auCpuIdRanges[i], 0, &cLeafs, &uEBX, &uECX, &uEDX));
559 if (cLeafs < s_auCpuIdRanges[i] || cLeafs > s_auCpuIdRanges[i+1])
560 continue;
561 cLeafs++;
562 for (ULONG iLeaf = s_auCpuIdRanges[i]; iLeaf <= cLeafs; iLeaf++)
563 {
564 CHECK_ERROR(Host, GetProcessorCPUIDLeaf(uCpuNo, iLeaf, 0, &uEAX, &uEBX, &uECX, &uEDX));
565 RTPrintf("%08x %08x %08x %08x %08x\n", iLeaf, uEAX, uEBX, uECX, uEDX);
566 }
567 }
568 break;
569 }
570
571 /** @todo function. */
572 case kListHddBackends:
573 {
574 ComPtr<ISystemProperties> systemProperties;
575 CHECK_ERROR(rptrVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()));
576 com::SafeIfaceArray<IMediumFormat> mediumFormats;
577 CHECK_ERROR(systemProperties, COMGETTER(MediumFormats)(ComSafeArrayAsOutParam(mediumFormats)));
578
579 RTPrintf("Supported hard disk backends:\n\n");
580 for (size_t i = 0; i < mediumFormats.size(); ++i)
581 {
582 /* General information */
583 Bstr id;
584 CHECK_ERROR(mediumFormats[i], COMGETTER(Id)(id.asOutParam()));
585
586 Bstr description;
587 CHECK_ERROR(mediumFormats[i],
588 COMGETTER(Id)(description.asOutParam()));
589
590 ULONG caps;
591 CHECK_ERROR(mediumFormats[i],
592 COMGETTER(Capabilities)(&caps));
593
594 RTPrintf("Backend %u: id='%ls' description='%ls' capabilities=%#06x extensions='",
595 i, id.raw(), description.raw(), caps);
596
597 /* File extensions */
598 com::SafeArray <BSTR> fileExtensions;
599 com::SafeArray <DeviceType_T> deviceTypes;
600 CHECK_ERROR(mediumFormats[i],
601 DescribeFileExtensions(ComSafeArrayAsOutParam(fileExtensions), ComSafeArrayAsOutParam(deviceTypes)));
602 for (size_t j = 0; j < fileExtensions.size(); ++j)
603 {
604 RTPrintf("%ls (%s)", Bstr(fileExtensions[j]).raw(), getDeviceTypeText(deviceTypes[j]));
605 if (j != fileExtensions.size()-1)
606 RTPrintf(",");
607 }
608 RTPrintf("'");
609
610 /* Configuration keys */
611 com::SafeArray <BSTR> propertyNames;
612 com::SafeArray <BSTR> propertyDescriptions;
613 com::SafeArray <DataType_T> propertyTypes;
614 com::SafeArray <ULONG> propertyFlags;
615 com::SafeArray <BSTR> propertyDefaults;
616 CHECK_ERROR(mediumFormats[i],
617 DescribeProperties(ComSafeArrayAsOutParam(propertyNames),
618 ComSafeArrayAsOutParam(propertyDescriptions),
619 ComSafeArrayAsOutParam(propertyTypes),
620 ComSafeArrayAsOutParam(propertyFlags),
621 ComSafeArrayAsOutParam(propertyDefaults)));
622
623 RTPrintf(" properties=(");
624 if (propertyNames.size() > 0)
625 {
626 for (size_t j = 0; j < propertyNames.size(); ++j)
627 {
628 RTPrintf("\n name='%ls' desc='%ls' type=",
629 Bstr(propertyNames[j]).raw(), Bstr(propertyDescriptions[j]).raw());
630 switch (propertyTypes[j])
631 {
632 case DataType_Int32: RTPrintf("int"); break;
633 case DataType_Int8: RTPrintf("byte"); break;
634 case DataType_String: RTPrintf("string"); break;
635 }
636 RTPrintf(" flags=%#04x", propertyFlags[j]);
637 RTPrintf(" default='%ls'", Bstr(propertyDefaults[j]).raw());
638 if (j != propertyNames.size()-1)
639 RTPrintf(", ");
640 }
641 }
642 RTPrintf(")\n");
643 }
644 break;
645 }
646
647 case kListHdds:
648 {
649 com::SafeIfaceArray<IMedium> hdds;
650 CHECK_ERROR(rptrVirtualBox, COMGETTER(HardDisks)(ComSafeArrayAsOutParam(hdds)));
651 listMedia(rptrVirtualBox, hdds, "base");
652 break;
653 }
654
655 case kListDvds:
656 {
657 com::SafeIfaceArray<IMedium> dvds;
658 CHECK_ERROR(rptrVirtualBox, COMGETTER(DVDImages)(ComSafeArrayAsOutParam(dvds)));
659 listMedia(rptrVirtualBox, dvds, NULL);
660 break;
661 }
662
663 case kListFloppies:
664 {
665 com::SafeIfaceArray<IMedium> floppies;
666 CHECK_ERROR(rptrVirtualBox, COMGETTER(FloppyImages)(ComSafeArrayAsOutParam(floppies)));
667 listMedia(rptrVirtualBox, floppies, NULL);
668 break;
669 }
670
671 /** @todo function. */
672 case kListUsbHost:
673 {
674 ComPtr<IHost> Host;
675 CHECK_ERROR_RET(rptrVirtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
676
677 SafeIfaceArray<IHostUSBDevice> CollPtr;
678 CHECK_ERROR_RET(Host, COMGETTER(USBDevices)(ComSafeArrayAsOutParam(CollPtr)), 1);
679
680 RTPrintf("Host USB Devices:\n\n");
681
682 if (CollPtr.size() == 0)
683 {
684 RTPrintf("<none>\n\n");
685 }
686 else
687 {
688 for (size_t i = 0; i < CollPtr.size(); ++i)
689 {
690 ComPtr <IHostUSBDevice> dev = CollPtr[i];
691
692 /* Query info. */
693 Bstr id;
694 CHECK_ERROR_RET(dev, COMGETTER(Id)(id.asOutParam()), 1);
695 USHORT usVendorId;
696 CHECK_ERROR_RET(dev, COMGETTER(VendorId)(&usVendorId), 1);
697 USHORT usProductId;
698 CHECK_ERROR_RET(dev, COMGETTER(ProductId)(&usProductId), 1);
699 USHORT bcdRevision;
700 CHECK_ERROR_RET(dev, COMGETTER(Revision)(&bcdRevision), 1);
701
702 RTPrintf("UUID: %S\n"
703 "VendorId: %#06x (%04X)\n"
704 "ProductId: %#06x (%04X)\n"
705 "Revision: %u.%u (%02u%02u)\n",
706 Utf8Str(id).c_str(),
707 usVendorId, usVendorId, usProductId, usProductId,
708 bcdRevision >> 8, bcdRevision & 0xff,
709 bcdRevision >> 8, bcdRevision & 0xff);
710
711 /* optional stuff. */
712 Bstr bstr;
713 CHECK_ERROR_RET(dev, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
714 if (!bstr.isEmpty())
715 RTPrintf("Manufacturer: %lS\n", bstr.raw());
716 CHECK_ERROR_RET(dev, COMGETTER(Product)(bstr.asOutParam()), 1);
717 if (!bstr.isEmpty())
718 RTPrintf("Product: %lS\n", bstr.raw());
719 CHECK_ERROR_RET(dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
720 if (!bstr.isEmpty())
721 RTPrintf("SerialNumber: %lS\n", bstr.raw());
722 CHECK_ERROR_RET(dev, COMGETTER(Address)(bstr.asOutParam()), 1);
723 if (!bstr.isEmpty())
724 RTPrintf("Address: %lS\n", bstr.raw());
725
726 /* current state */
727 USBDeviceState_T state;
728 CHECK_ERROR_RET(dev, COMGETTER(State)(&state), 1);
729 const char *pszState = "?";
730 switch (state)
731 {
732 case USBDeviceState_NotSupported:
733 pszState = "Not supported";
734 break;
735 case USBDeviceState_Unavailable:
736 pszState = "Unavailable";
737 break;
738 case USBDeviceState_Busy:
739 pszState = "Busy";
740 break;
741 case USBDeviceState_Available:
742 pszState = "Available";
743 break;
744 case USBDeviceState_Held:
745 pszState = "Held";
746 break;
747 case USBDeviceState_Captured:
748 pszState = "Captured";
749 break;
750 default:
751 ASSERT(false);
752 break;
753 }
754 RTPrintf("Current State: %s\n\n", pszState);
755 }
756 }
757 break;
758 }
759
760 /** @todo function. */
761 case kListUsbFilters:
762 {
763 RTPrintf("Global USB Device Filters:\n\n");
764
765 ComPtr<IHost> host;
766 CHECK_ERROR_RET(rptrVirtualBox, COMGETTER(Host)(host.asOutParam()), 1);
767
768 SafeIfaceArray<IHostUSBDeviceFilter> coll;
769 CHECK_ERROR_RET(host, COMGETTER(USBDeviceFilters)(ComSafeArrayAsOutParam(coll)), 1);
770
771 if (coll.size() == 0)
772 {
773 RTPrintf("<none>\n\n");
774 }
775 else
776 {
777 for (size_t index = 0; index < coll.size(); ++index)
778 {
779 ComPtr<IHostUSBDeviceFilter> flt = coll[index];
780
781 /* Query info. */
782
783 RTPrintf("Index: %zu\n", index);
784
785 BOOL active = FALSE;
786 CHECK_ERROR_RET(flt, COMGETTER(Active)(&active), 1);
787 RTPrintf("Active: %s\n", active ? "yes" : "no");
788
789 USBDeviceFilterAction_T action;
790 CHECK_ERROR_RET(flt, COMGETTER(Action)(&action), 1);
791 const char *pszAction = "<invalid>";
792 switch (action)
793 {
794 case USBDeviceFilterAction_Ignore:
795 pszAction = "Ignore";
796 break;
797 case USBDeviceFilterAction_Hold:
798 pszAction = "Hold";
799 break;
800 default:
801 break;
802 }
803 RTPrintf("Action: %s\n", pszAction);
804
805 Bstr bstr;
806 CHECK_ERROR_RET(flt, COMGETTER(Name)(bstr.asOutParam()), 1);
807 RTPrintf("Name: %lS\n", bstr.raw());
808 CHECK_ERROR_RET(flt, COMGETTER(VendorId)(bstr.asOutParam()), 1);
809 RTPrintf("VendorId: %lS\n", bstr.raw());
810 CHECK_ERROR_RET(flt, COMGETTER(ProductId)(bstr.asOutParam()), 1);
811 RTPrintf("ProductId: %lS\n", bstr.raw());
812 CHECK_ERROR_RET(flt, COMGETTER(Revision)(bstr.asOutParam()), 1);
813 RTPrintf("Revision: %lS\n", bstr.raw());
814 CHECK_ERROR_RET(flt, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
815 RTPrintf("Manufacturer: %lS\n", bstr.raw());
816 CHECK_ERROR_RET(flt, COMGETTER(Product)(bstr.asOutParam()), 1);
817 RTPrintf("Product: %lS\n", bstr.raw());
818 CHECK_ERROR_RET(flt, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
819 RTPrintf("Serial Number: %lS\n\n", bstr.raw());
820 }
821 }
822 break;
823 }
824
825 /** @todo function. */
826 case kListSystemProperties:
827 {
828 ComPtr<ISystemProperties> systemProperties;
829 rptrVirtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
830
831 Bstr str;
832 ULONG ulValue;
833 LONG64 i64Value;
834
835 systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
836 RTPrintf("Minimum guest RAM size: %u Megabytes\n", ulValue);
837 systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
838 RTPrintf("Maximum guest RAM size: %u Megabytes\n", ulValue);
839 systemProperties->COMGETTER(MinGuestVRAM)(&ulValue);
840 RTPrintf("Minimum video RAM size: %u Megabytes\n", ulValue);
841 systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
842 RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue);
843 systemProperties->COMGETTER(MinGuestCPUCount)(&ulValue);
844 RTPrintf("Minimum guest CPU count: %u\n", ulValue);
845 systemProperties->COMGETTER(MaxGuestCPUCount)(&ulValue);
846 RTPrintf("Maximum guest CPU count: %u\n", ulValue);
847 systemProperties->COMGETTER(InfoVDSize)(&i64Value);
848 RTPrintf("Virtual disk limit (info): %lld Bytes\n", i64Value);
849 systemProperties->COMGETTER(NetworkAdapterCount)(&ulValue);
850 RTPrintf("Maximum Network Adapter count: %u\n", ulValue);
851 systemProperties->COMGETTER(SerialPortCount)(&ulValue);
852 RTPrintf("Maximum Serial Port count: %u\n", ulValue);
853 systemProperties->COMGETTER(ParallelPortCount)(&ulValue);
854 RTPrintf("Maximum Parallel Port count: %u\n", ulValue);
855 systemProperties->COMGETTER(MaxBootPosition)(&ulValue);
856 RTPrintf("Maximum Boot Position: %u\n", ulValue);
857 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_IDE, &ulValue);
858 RTPrintf("Maximum PIIX3 IDE Controllers: %u\n", ulValue);
859 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_IDE, &ulValue);
860 RTPrintf("Maximum ICH9 IDE Controllers: %u\n", ulValue);
861 systemProperties->GetMaxPortCountForStorageBus(StorageBus_IDE, &ulValue);
862 RTPrintf("Maximum IDE Port count: %u\n", ulValue);
863 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_IDE, &ulValue);
864 RTPrintf("Maximum Devices per IDE Port: %u\n", ulValue);
865 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SATA, &ulValue);
866 RTPrintf("Maximum PIIX3 SATA Controllers: %u\n", ulValue);
867 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SATA, &ulValue);
868 RTPrintf("Maximum ICH9 SATA Controllers: %u\n", ulValue);
869 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SATA, &ulValue);
870 RTPrintf("Maximum SATA Port count: %u\n", ulValue);
871 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SATA, &ulValue);
872 RTPrintf("Maximum Devices per SATA Port: %u\n", ulValue);
873 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SCSI, &ulValue);
874 RTPrintf("Maximum PIIX3 SCSI Controllers: %u\n", ulValue);
875 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SCSI, &ulValue);
876 RTPrintf("Maximum ICH9 SCSI Controllers: %u\n", ulValue);
877 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SCSI, &ulValue);
878 RTPrintf("Maximum SCSI Port count: %u\n", ulValue);
879 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SCSI, &ulValue);
880 RTPrintf("Maximum Devices per SCSI Port: %u\n", ulValue);
881 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_SAS, &ulValue);
882 RTPrintf("Maximum SAS PIIX3 Controllers: %u\n", ulValue);
883 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_SAS, &ulValue);
884 RTPrintf("Maximum SAS ICH9 Controllers: %u\n", ulValue);
885 systemProperties->GetMaxPortCountForStorageBus(StorageBus_SAS, &ulValue);
886 RTPrintf("Maximum SAS Port count: %u\n", ulValue);
887 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_SAS, &ulValue);
888 RTPrintf("Maximum Devices per SAS Port: %u\n", ulValue);
889 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_PIIX3, StorageBus_Floppy, &ulValue);
890 RTPrintf("Maximum PIIX3 Floppy Controllers:%u\n", ulValue);
891 systemProperties->GetMaxInstancesOfStorageBus(ChipsetType_ICH9, StorageBus_Floppy, &ulValue);
892 RTPrintf("Maximum ICH9 Floppy Controllers: %u\n", ulValue);
893 systemProperties->GetMaxPortCountForStorageBus(StorageBus_Floppy, &ulValue);
894 RTPrintf("Maximum Floppy Port count: %u\n", ulValue);
895 systemProperties->GetMaxDevicesPerPortForStorageBus(StorageBus_Floppy, &ulValue);
896 RTPrintf("Maximum Devices per Floppy Port: %u\n", ulValue);
897 systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
898 RTPrintf("Default machine folder: %lS\n", str.raw());
899 systemProperties->COMGETTER(VRDEAuthLibrary)(str.asOutParam());
900 RTPrintf("VRDE auth library: %lS\n", str.raw());
901 systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
902 RTPrintf("Webservice auth. library: %lS\n", str.raw());
903 systemProperties->COMGETTER(DefaultVRDEExtPack)(str.asOutParam());
904 RTPrintf("Remote desktop ExtPack: %lS\n", str.raw());
905 systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
906 RTPrintf("Log history count: %u\n", ulValue);
907 break;
908 }
909
910 case kListDhcpServers:
911 {
912 com::SafeIfaceArray<IDHCPServer> svrs;
913 CHECK_ERROR(rptrVirtualBox, COMGETTER(DHCPServers)(ComSafeArrayAsOutParam(svrs)));
914 for (size_t i = 0; i < svrs.size(); ++i)
915 {
916 ComPtr<IDHCPServer> svr = svrs[i];
917 Bstr netName;
918 svr->COMGETTER(NetworkName)(netName.asOutParam());
919 RTPrintf("NetworkName: %lS\n", netName.raw());
920 Bstr ip;
921 svr->COMGETTER(IPAddress)(ip.asOutParam());
922 RTPrintf("IP: %lS\n", ip.raw());
923 Bstr netmask;
924 svr->COMGETTER(NetworkMask)(netmask.asOutParam());
925 RTPrintf("NetworkMask: %lS\n", netmask.raw());
926 Bstr lowerIp;
927 svr->COMGETTER(LowerIP)(lowerIp.asOutParam());
928 RTPrintf("lowerIPAddress: %lS\n", lowerIp.raw());
929 Bstr upperIp;
930 svr->COMGETTER(UpperIP)(upperIp.asOutParam());
931 RTPrintf("upperIPAddress: %lS\n", upperIp.raw());
932 BOOL fEnabled;
933 svr->COMGETTER(Enabled)(&fEnabled);
934 RTPrintf("Enabled: %s\n", fEnabled ? "Yes" : "No");
935 RTPrintf("\n");
936 }
937 break;
938 }
939
940 case kListExtPacks:
941 rc = listExtensionPacks(rptrVirtualBox);
942 break;
943
944 /* No default here, want gcc warnings. */
945
946 } /* end switch */
947
948 return rc;
949}
950
951/**
952 * Handles the 'list' command.
953 *
954 * @returns Appropriate exit code.
955 * @param a Handler argument.
956 */
957int handleList(HandlerArg *a)
958{
959 bool fOptLong = false;
960 bool fOptMultiple = false;
961 enum enmListType enmOptCommand = kListNotSpecified;
962
963 static const RTGETOPTDEF s_aListOptions[] =
964 {
965 { "--long", 'l', RTGETOPT_REQ_NOTHING },
966 { "--multiple", 'm', RTGETOPT_REQ_NOTHING }, /* not offical yet */
967 { "vms", kListVMs, RTGETOPT_REQ_NOTHING },
968 { "runningvms", kListRunningVMs, RTGETOPT_REQ_NOTHING },
969 { "ostypes", kListOsTypes, RTGETOPT_REQ_NOTHING },
970 { "hostdvds", kListHostDvds, RTGETOPT_REQ_NOTHING },
971 { "hostfloppies", kListHostFloppies, RTGETOPT_REQ_NOTHING },
972 { "hostifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING }, /* backward compatibility */
973 { "bridgedifs", kListBridgedInterfaces, RTGETOPT_REQ_NOTHING },
974#if defined(VBOX_WITH_NETFLT)
975 { "hostonlyifs", kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
976#endif
977 { "hostinfo", kListHostInfo, RTGETOPT_REQ_NOTHING },
978 { "hostcpuids", kListHostCpuIDs, RTGETOPT_REQ_NOTHING },
979 { "hddbackends", kListHddBackends, RTGETOPT_REQ_NOTHING },
980 { "hdds", kListHdds, RTGETOPT_REQ_NOTHING },
981 { "dvds", kListDvds, RTGETOPT_REQ_NOTHING },
982 { "floppies", kListFloppies, RTGETOPT_REQ_NOTHING },
983 { "usbhost", kListUsbHost, RTGETOPT_REQ_NOTHING },
984 { "usbfilters", kListUsbFilters, RTGETOPT_REQ_NOTHING },
985 { "systemproperties", kListSystemProperties, RTGETOPT_REQ_NOTHING },
986 { "dhcpservers", kListDhcpServers, RTGETOPT_REQ_NOTHING },
987 { "extpacks", kListExtPacks, RTGETOPT_REQ_NOTHING },
988 };
989
990 int ch;
991 RTGETOPTUNION ValueUnion;
992 RTGETOPTSTATE GetState;
993 RTGetOptInit(&GetState, a->argc, a->argv, s_aListOptions, RT_ELEMENTS(s_aListOptions),
994 0, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
995 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
996 {
997 switch (ch)
998 {
999 case 'l': /* --long */
1000 fOptLong = true;
1001 break;
1002
1003 case 'm':
1004 fOptMultiple = true;
1005 if (enmOptCommand == kListNotSpecified)
1006 break;
1007 ch = enmOptCommand;
1008 /* fall thru */
1009
1010 case kListVMs:
1011 case kListRunningVMs:
1012 case kListOsTypes:
1013 case kListHostDvds:
1014 case kListHostFloppies:
1015 case kListBridgedInterfaces:
1016#if defined(VBOX_WITH_NETFLT)
1017 case kListHostOnlyInterfaces:
1018#endif
1019 case kListHostInfo:
1020 case kListHostCpuIDs:
1021 case kListHddBackends:
1022 case kListHdds:
1023 case kListDvds:
1024 case kListFloppies:
1025 case kListUsbHost:
1026 case kListUsbFilters:
1027 case kListSystemProperties:
1028 case kListDhcpServers:
1029 case kListExtPacks:
1030 enmOptCommand = (enum enmListType)ch;
1031 if (fOptMultiple)
1032 {
1033 HRESULT hrc = produceList((enum enmListType)ch, fOptLong, a->virtualBox);
1034 if (FAILED(hrc))
1035 return 1;
1036 }
1037 break;
1038
1039 case VINF_GETOPT_NOT_OPTION:
1040 return errorSyntax(USAGE_LIST, "Unknown subcommand \"%s\".", ValueUnion.psz);
1041
1042 default:
1043 return errorGetOpt(USAGE_LIST, ch, &ValueUnion);
1044 }
1045 }
1046
1047 /*
1048 * If not in multiple list mode, we have to produce the list now.
1049 */
1050 if (enmOptCommand == kListNotSpecified)
1051 return errorSyntax(USAGE_LIST, "Missing subcommand for \"list\" command.\n");
1052 if (!fOptMultiple)
1053 {
1054 HRESULT hrc = produceList(enmOptCommand, fOptLong, a->virtualBox);
1055 if (FAILED(hrc))
1056 return 1;
1057 }
1058
1059 return 0;
1060}
1061
1062#endif /* !VBOX_ONLY_DOCS */
1063/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use