VBoxManageList.cpp@ 40673

Last change on this file since 40673 was 40540, checked in by vboxsync, 13 years ago
Frontends/VBoxManage: use new API method to get the machine state of several VMs, faster than old way for getting the list of running VMs
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 45.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: