VBoxManage.cpp@ 6676

Last change on this file since 6676 was 6660, checked in by vboxsync, 17 years ago
VBoxManage: don't show -type gui\|vrdp if VRDP is not available
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 274.2 KB

Line
1	/** @file
2	*
3	* VBox frontends: VBoxManage (command-line interface)
4	*
5	* VBoxManage is VirtualBox's command-line interface. This is its rather
6	* long source.
7	*/
8
9	/*
10	* Copyright (C) 2006-2007 innotek GmbH
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*/
20
21
22	/*******************************************************************************
23	* Header Files *
24	*******************************************************************************/
25
26	#include <VBox/com/com.h>
27	#include <VBox/com/string.h>
28	#include <VBox/com/Guid.h>
29	#include <VBox/com/ErrorInfo.h>
30	#include <VBox/com/EventQueue.h>
31
32	#include <VBox/com/VirtualBox.h>
33
34	/// @todo later, when the settings file update funciton is reimplemented using
35	/// libxslt (search for CFGLDR to find related parts of code below)
36	// #include <VBox/settings.h>
37
38	#include <stdlib.h>
39	#include <stdarg.h>
40
41	#include <vector>
42
43	#include <iprt/runtime.h>
44	#include <iprt/stream.h>
45	#include <iprt/string.h>
46	#include <iprt/asm.h>
47	#include <iprt/uuid.h>
48	#include <iprt/thread.h>
49	#include <iprt/path.h>
50	#include <iprt/param.h>
51	#include <iprt/dir.h>
52	#include <iprt/file.h>
53	#include <iprt/env.h>
54	#include <VBox/err.h>
55	#include <VBox/version.h>
56	#include <VBox/VBoxHDD.h>
57
58	#include "VBoxManage.h"
59
60	using namespace com;
61
62	/* missing XPCOM <-> COM wrappers */
63	#ifndef STDMETHOD_
64	# define STDMETHOD_(ret, meth) NS_IMETHOD_(ret) meth
65	#endif
66	#ifndef NS_GET_IID
67	# define NS_GET_IID(I) IID_##I
68	#endif
69	#ifndef RT_OS_WINDOWS
70	#define IUnknown nsISupports
71	#endif
72
73	/** command handler type */
74	typedef DECLCALLBACK(int) FNHANDLER(int argc, char *argv[], ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession);
75	typedef FNHANDLER *PFNHANDLER;
76
77	/**
78	* Quick IUSBDevice implementation for detaching / attaching
79	* devices to the USB Controller.
80	*/
81	class MyUSBDevice : public IUSBDevice
82	{
83	public:
84	// public initializer/uninitializer for internal purposes only
85	MyUSBDevice(uint16_t a_u16VendorId, uint16_t a_u16ProductId, uint16_t a_bcdRevision, uint64_t a_u64SerialHash, const char *a_pszComment)
86	: m_usVendorId(a_u16VendorId), m_usProductId(a_u16ProductId),
87	m_bcdRevision(a_bcdRevision), m_u64SerialHash(a_u64SerialHash),
88	m_bstrComment(a_pszComment),
89	m_cRefs(0)
90	{
91	}
92
93	STDMETHOD_(ULONG, AddRef)(void)
94	{
95	return ASMAtomicIncU32(&m_cRefs);
96	}
97	STDMETHOD_(ULONG, Release)(void)
98	{
99	ULONG cRefs = ASMAtomicDecU32(&m_cRefs);
100	if (!cRefs)
101	delete this;
102	return cRefs;
103	}
104	STDMETHOD(QueryInterface)(const IID &iid, void **ppvObject)
105	{
106	Guid guid(iid);
107	if (guid == Guid(NS_GET_IID(IUnknown)))
108	ppvObject = (IUnknown )this;
109	else if (guid == Guid(NS_GET_IID(IUSBDevice)))
110	ppvObject = (IUSBDevice )this;
111	else
112	return E_NOINTERFACE;
113	AddRef();
114	return S_OK;
115	}
116
117	STDMETHOD(COMGETTER(Id))(GUIDPARAMOUT a_pId) { return E_NOTIMPL; }
118	STDMETHOD(COMGETTER(VendorId))(USHORT a_pusVendorId) { a_pusVendorId = m_usVendorId; return S_OK; }
119	STDMETHOD(COMGETTER(ProductId))(USHORT a_pusProductId) { a_pusProductId = m_usProductId; return S_OK; }
120	STDMETHOD(COMGETTER(Revision))(USHORT a_pusRevision) { a_pusRevision = m_bcdRevision; return S_OK; }
121	STDMETHOD(COMGETTER(SerialHash))(ULONG64 a_pullSerialHash) { a_pullSerialHash = m_u64SerialHash; return S_OK; }
122	STDMETHOD(COMGETTER(Manufacturer))(BSTR *a_pManufacturer) { return E_NOTIMPL; }
123	STDMETHOD(COMGETTER(Product))(BSTR *a_pProduct) { return E_NOTIMPL; }
124	STDMETHOD(COMGETTER(SerialNumber))(BSTR *a_pSerialNumber) { return E_NOTIMPL; }
125	STDMETHOD(COMGETTER(Address))(BSTR *a_pAddress) { return E_NOTIMPL; }
126
127	private:
128	/** The vendor id of this USB device. */
129	USHORT m_usVendorId;
130	/** The product id of this USB device. */
131	USHORT m_usProductId;
132	/** The product revision number of this USB device.
133	* (high byte = integer; low byte = decimal) */
134	USHORT m_bcdRevision;
135	/** The USB serial hash of the device. */
136	uint64_t m_u64SerialHash;
137	/** The user comment string. */
138	Bstr m_bstrComment;
139	/** Reference counter. */
140	uint32_t volatile m_cRefs;
141	};
142
143
144	// types
145	///////////////////////////////////////////////////////////////////////////////
146
147	template <typename T>
148	class Nullable
149	{
150	public:
151
152	Nullable() : mIsNull (true) {}
153	Nullable (const T &aValue, bool aIsNull = false)
154	: mIsNull (aIsNull), mValue (aValue) {}
155
156	bool isNull() const { return mIsNull; };
157	void setNull (bool aIsNull = true) { mIsNull = aIsNull; }
158
159	operator const T&() const { return mValue; }
160
161	Nullable &operator= (const T &aValue)
162	{
163	mValue = aValue;
164	mIsNull = false;
165	return *this;
166	}
167
168	private:
169
170	bool mIsNull;
171	T mValue;
172	};
173
174	/** helper structure to encapsulate USB filter manipulation commands */
175	struct USBFilterCmd
176	{
177	struct USBFilter
178	{
179	USBFilter ()
180	: mAction (USBDeviceFilterAction_InvalidUSBDeviceFilterAction)
181	{}
182
183	Bstr mName;
184	Nullable <bool> mActive;
185	Bstr mVendorId;
186	Bstr mProductId;
187	Bstr mRevision;
188	Bstr mManufacturer;
189	Bstr mProduct;
190	Bstr mRemote;
191	Bstr mSerialNumber;
192	Nullable <ULONG> mMaskedInterfaces;
193	USBDeviceFilterAction_T mAction;
194	};
195
196	enum Action { Invalid, Add, Modify, Remove };
197
198	USBFilterCmd() : mAction (Invalid), mIndex (0), mGlobal (false) {}
199
200	Action mAction;
201	ULONG mIndex;
202	/** flag whether the command target is a global filter */
203	bool mGlobal;
204	/** machine this command is targeted at (null for global filters) */
205	ComPtr<IMachine> mMachine;
206	USBFilter mFilter;
207	};
208
209	// funcs
210	///////////////////////////////////////////////////////////////////////////////
211
212	static void showLogo(void)
213	{
214	static bool fShown; /* show only once */
215
216	if (!fShown)
217	{
218	RTPrintf("VirtualBox Command Line Management Interface Version "
219	VBOX_VERSION_STRING "\n"
220	"(C) 2005-2008 innotek GmbH\n"
221	"All rights reserved.\n"
222	"\n");
223	fShown = true;
224	}
225	}
226
227	static void printUsage(USAGECATEGORY u64Cmd)
228	{
229	#ifdef RT_OS_LINUX
230	bool fLinux = true;
231	#else
232	bool fLinux = false;
233	#endif
234	#ifdef RT_OS_WINDOWS
235	bool fWin = true;
236	#else
237	bool fWin = false;
238	#endif
239	#ifdef RT_OS_DARWIN
240	bool fDarwin = true;
241	#else
242	bool fDarwin = false;
243	#endif
244	#ifdef VBOX_VRDP
245	bool fVRDP = true;
246	#else
247	bool fVRDP = false;
248	#endif
249
250	if (u64Cmd == USAGE_DUMPOPTS)
251	{
252	fLinux = true;
253	fWin = true;
254	fVRDP = true;
255	u64Cmd = USAGE_ALL;
256	}
257
258	RTPrintf("Usage:\n"
259	"\n");
260
261	if (u64Cmd == USAGE_ALL)
262	{
263	RTPrintf("VBoxManage [-v\|-version] print version number and exit\n");
264	RTPrintf("VBoxManage -nologo ... suppress the logo\n"
265	"\n");
266	}
267
268	if (u64Cmd & USAGE_LIST)
269	{
270	RTPrintf("VBoxManage list vms\|runningvms\|ostypes\|hostdvds\|hostfloppies\|\n");
271	if (fWin)
272	RTPrintf( "hostifs\|");
273	RTPrintf(" hdds\|dvds\|floppies\|usbhost\|usbfilters\|\n"
274	" systemproperties\n"
275	"\n");
276	}
277
278	if (u64Cmd & USAGE_SHOWVMINFO)
279	{
280	RTPrintf("VBoxManage showvminfo <uuid>\|<name>\n"
281	" [-details]\n"
282	" [-statistics]\n"
283	" [-machinereadable]\n"
284	"\n");
285	}
286
287	if (u64Cmd & USAGE_REGISTERVM)
288	{
289	RTPrintf("VBoxManage registervm <filename>\n"
290	"\n");
291	}
292
293	if (u64Cmd & USAGE_UNREGISTERVM)
294	{
295	RTPrintf("VBoxManage unregistervm <uuid>\|<name>\n"
296	" [-delete]\n"
297	"\n");
298	}
299
300	if (u64Cmd & USAGE_CREATEVM)
301	{
302	RTPrintf("VBoxManage createvm -name <name>\n"
303	" [-register]\n"
304	" [-basefolder <path> \| -settingsfile <path>]\n"
305	" [-uuid <uuid>]\n"
306	" \n"
307	"\n");
308	}
309
310	if (u64Cmd & USAGE_MODIFYVM)
311	{
312	RTPrintf("VBoxManage modifyvm <uuid\|name>\n"
313	" [-name <name>]\n"
314	" [-ostype <ostype>]\n"
315	" [-memory <memorysize>]\n"
316	" [-vram <vramsize>]\n"
317	" [-acpi on\|off]\n"
318	" [-ioapic on\|off]\n"
319	" [-hwvirtex on\|off\|default]\n"
320	" [-monitorcount <number>]\n"
321	" [-bioslogofadein on\|off]\n"
322	" [-bioslogofadeout on\|off]\n"
323	" [-bioslogodisplaytime <msec>]\n"
324	" [-bioslogoimagepath <imagepath>]\n"
325	" [-biosbootmenu disabled\|menuonly\|messageandmenu]\n"
326	" [-biossystemtimeoffset <msec>]\n"
327	" [-biospxedebug on\|off]\n"
328	" [-boot<1-4> none\|floppy\|dvd\|disk\|net>]\n"
329	" [-hd<a\|b\|d> none\|<uuid>\|<filename>]\n"
330	" [-dvd none\|<uuid>\|<filename>\|host:<drive>]\n"
331	" [-dvdpassthrough on\|off]\n"
332	" [-floppy disabled\|empty\|<uuid>\|\n"
333	" <filename>\|host:<drive>]\n"
334	" [-nic<1-N> none\|null\|nat\|hostif\|intnet]\n"
335	" [-nictype<1-N> Am79C970A\|Am79C973]\n"
336	" [-cableconnected<1-N> on\|off]\n"
337	" [-nictrace<1-N> on\|off]\n"
338	" [-nictracefile<1-N> <filename>]\n"
339	" [-nicspeed<1-N> <kbps>]\n"
340	" [-hostifdev<1-N> none\|<devicename>]\n"
341	" [-intnet<1-N> <network>]\n"
342	" [-macaddress<1-N> auto\|<mac>]\n"
343	" [-uart<1-N> off\|<I/O base> <IRQ>]\n"
344	" [-uartmode<1-N> disconnected\|\n"
345	" server <pipe>\|\n"
346	" client <pipe>\|\n"
347	" <devicename>]\n"
348	" [-guestmemoryballoon <balloonsize>]\n"
349	" [-gueststatisticsinterval <seconds>]\n"
350	);
351	if (fLinux)
352	{
353	RTPrintf(" [-tapsetup<1-N> none\|<application>]\n"
354	" [-tapterminate<1-N> none\|<application>]\n");
355	}
356	RTPrintf(" [-audio none\|null");
357	if (fWin)
358	{
359	#ifdef VBOX_WITH_WINMM
360	RTPrintf( "\|winmm\|dsound");
361	#else
362	RTPrintf( "\|dsound");
363	#endif
364	}
365	if (fLinux)
366	{
367	RTPrintf( "\|oss"
368	#ifdef VBOX_WITH_ALSA
369	"\|alsa"
370	#endif
371	#ifdef VBOX_WITH_PULSE
372	"\|pulse"
373	#endif
374	);
375	}
376	if (fDarwin)
377	{
378	RTPrintf( "\|coreaudio");
379	}
380	RTPrintf( "]\n");
381	RTPrintf(" [-audiocontroller ac97\|sb16]\n"
382	" [-clipboard disabled\|hosttoguest\|guesttohost\|\n"
383	" bidirectional]\n");
384	if (fVRDP)
385	{
386	RTPrintf(" [-vrdp on\|off]\n"
387	" [-vrdpport default\|<port>]\n"
388	" [-vrdpaddress <host>]\n"
389	" [-vrdpauthtype null\|external\|guest]\n"
390	" [-vrdpmulticon on\|off]\n");
391	}
392	RTPrintf(" [-usb on\|off]\n"
393	" [-usbehci on\|off]\n"
394	" [-snapshotfolder default\|<path>]\n"
395	"\n");
396	}
397
398	if (u64Cmd & USAGE_STARTVM)
399	{
400	RTPrintf("VBoxManage startvm <uuid>\|<name>\n");
401	if (fVRDP)
402	RTPrintf(" [-type gui\|vrdp]\n");
403	RTPrintf("\n");
404	}
405
406	if (u64Cmd & USAGE_CONTROLVM)
407	{
408	RTPrintf("VBoxManage controlvm <uuid>\|<name>\n"
409	" pause\|resume\|reset\|poweroff\|savestate\|\n"
410	" acpipowerbutton\|acpisleepbutton\|\n"
411	" setlinkstate<1-4> on\|off \|\n"
412	" usbattach <uuid>\|<address> \|\n"
413	" usbdetach <uuid>\|<address> \|\n"
414	" dvdattach none\|<uuid>\|<filename>\|host:<drive> \|\n"
415	" floppyattach none\|<uuid>\|<filename>\|host:<drive> \|\n"
416	" setvideomodehint <xres> <yres> <bpp> [display]\|\n"
417	" setcredentials <username> <password> <domain>\n"
418	" [-allowlocallogon <yes\|no>]\n"
419	"\n");
420	}
421
422	if (u64Cmd & USAGE_DISCARDSTATE)
423	{
424	RTPrintf("VBoxManage discardstate <uuid>\|<name>\n"
425	"\n");
426	}
427
428	if (u64Cmd & USAGE_ADOPTSTATE)
429	{
430	RTPrintf("VBoxManage adoptstate <uuid>\|<name> <state_file>\n"
431	"\n");
432	}
433
434	if (u64Cmd & USAGE_SNAPSHOT)
435	{
436	RTPrintf("VBoxManage snapshot <uuid>\|<name>\n"
437	" take <name> [-desc <desc>] \|\n"
438	" discard <uuid>\|<name> \|\n"
439	" discardcurrent -state\|-all \|\n"
440	" edit <uuid>\|<name>\|-current\n"
441	" [-newname <name>]\n"
442	" [-newdesc <desc>] \|\n"
443	" showvminfo <uuid>\|<name>\n"
444	"\n");
445	}
446
447	if (u64Cmd & USAGE_REGISTERIMAGE)
448	{
449	RTPrintf("VBoxManage registerimage disk\|dvd\|floppy <filename>\n"
450	" [-type normal\|immutable\|writethrough] (disk only)\n"
451	"\n");
452	}
453
454	if (u64Cmd & USAGE_UNREGISTERIMAGE)
455	{
456	RTPrintf("VBoxManage unregisterimage disk\|dvd\|floppy <uuid>\|<filename>\n"
457	"\n");
458	}
459
460	if (u64Cmd & USAGE_SHOWVDIINFO)
461	{
462	RTPrintf("VBoxManage showvdiinfo <uuid>\|<filename>\n"
463	"\n");
464	}
465
466	if (u64Cmd & USAGE_CREATEVDI)
467	{
468	RTPrintf("VBoxManage createvdi -filename <filename>\n"
469	" -size <megabytes>\n"
470	" [-static]\n"
471	" [-comment <comment>]\n"
472	" [-register]\n"
473	" [-type normal\|writethrough] (default: normal)\n"
474	"\n");
475	}
476
477	if (u64Cmd & USAGE_MODIFYVDI)
478	{
479	RTPrintf("VBoxManage modifyvdi <uuid>\|<filename>\n"
480	#if 0 /* doesn't currently work */
481	" settype normal\|writethrough\|immutable \|\n"
482	#endif
483	" compact\n"
484	"\n");
485	}
486
487	if (u64Cmd & USAGE_CLONEVDI)
488	{
489	RTPrintf("VBoxManage clonevdi <uuid>\|<filename> <outputfile>\n"
490	"\n");
491	}
492
493	if (u64Cmd & USAGE_CONVERTDD)
494	{
495	RTPrintf("VBoxManage convertdd <filename> <outputfile>\n"
496	"VBoxManage convertdd stdin <outputfile> <bytes>\n"
497	"\n");
498	}
499
500	if (u64Cmd & USAGE_ADDISCSIDISK)
501	{
502	RTPrintf("VBoxManage addiscsidisk -server <name>\|<ip>\n"
503	" -target <target>\n"
504	" [-port <port>]\n"
505	" [-lun <lun>]\n"
506	" [-encodedlun <lun>]\n"
507	" [-username <username>]\n"
508	" [-password <password>]\n"
509	" [-comment <comment>]\n"
510	"\n");
511	}
512
513	if (u64Cmd & USAGE_CREATEHOSTIF && fWin)
514	{
515	RTPrintf("VBoxManage createhostif <name>\n"
516	"\n");
517	}
518
519	if (u64Cmd & USAGE_REMOVEHOSTIF && fWin)
520	{
521	RTPrintf("VBoxManage removehostif <uuid>\|<name>\n"
522	"\n");
523	}
524
525	if (u64Cmd & USAGE_GETEXTRADATA)
526	{
527	RTPrintf("VBoxManage getextradata global\|<uuid>\|<name>\n"
528	" <key>\|enumerate\n"
529	"\n");
530	}
531
532	if (u64Cmd & USAGE_SETEXTRADATA)
533	{
534	RTPrintf("VBoxManage setextradata global\|<uuid>\|<name>\n"
535	" <key>\n"
536	" [<value>] (no value deletes key)\n"
537	"\n");
538	}
539
540	if (u64Cmd & USAGE_SETPROPERTY)
541	{
542	RTPrintf("VBoxManage setproperty vdifolder default\|<folder> \|\n"
543	" machinefolder default\|<folder> \|\n"
544	" vrdpauthlibrary default\|<library> \|\n"
545	" websrvauthlibrary default\|null\|<library> \|\n"
546	" hwvirtexenabled yes\|no\n"
547	" loghistorycount <value>\n"
548	"\n");
549	}
550
551	if (u64Cmd & USAGE_USBFILTER_ADD)
552	{
553	RTPrintf("VBoxManage usbfilter add <index,0-N>\n"
554	" -target <uuid>\|<name>\|global\n"
555	" -name <string>\n"
556	" -action ignore\|hold (global filters only)\n"
557	" [-active yes\|no] (yes)\n"
558	" [-vendorid <XXXX>] (null)\n"
559	" [-productid <XXXX>] (null)\n"
560	" [-revision <IIFF>] (null)\n"
561	" [-manufacturer <string>] (null)\n"
562	" [-product <string>] (null)\n"
563	" [-remote yes\|no] (null, VM filters only)\n"
564	" [-serialnumber <string>] (null)\n"
565	" [-maskedinterfaces <XXXXXXXX>]\n"
566	"\n");
567	}
568
569	if (u64Cmd & USAGE_USBFILTER_MODIFY)
570	{
571	RTPrintf("VBoxManage usbfilter modify <index,0-N>\n"
572	" -target <uuid>\|<name>\|global\n"
573	" [-name <string>]\n"
574	" [-action ignore\|hold] (global filters only)\n"
575	" [-active yes\|no]\n"
576	" [-vendorid <XXXX>\|\"\"]\n"
577	" [-productid <XXXX>\|\"\"]\n"
578	" [-revision <IIFF>\|\"\"]\n"
579	" [-manufacturer <string>\|\"\"]\n"
580	" [-product <string>\|\"\"]\n"
581	" [-remote yes\|no] (null, VM filters only)\n"
582	" [-serialnumber <string>\|\"\"]\n"
583	" [-maskedinterfaces <XXXXXXXX>]\n"
584	"\n");
585	}
586
587	if (u64Cmd & USAGE_USBFILTER_REMOVE)
588	{
589	RTPrintf("VBoxManage usbfilter remove <index,0-N>\n"
590	" -target <uuid>\|<name>\|global\n"
591	"\n");
592	}
593
594	if (u64Cmd & USAGE_SHAREDFOLDER_ADD)
595	{
596	RTPrintf("VBoxManage sharedfolder add <vmname>\|<uuid>\n"
597	" -name <name> -hostpath <hostpath>\n"
598	" [-transient] [-readonly]\n"
599	"\n");
600	}
601
602	if (u64Cmd & USAGE_SHAREDFOLDER_REMOVE)
603	{
604	RTPrintf("VBoxManage sharedfolder remove <vmname>\|<uuid>\n"
605	" -name <name> [-transient]\n"
606	"\n");
607	}
608
609	if (u64Cmd & USAGE_UPDATESETTINGS)
610	{
611	RTPrintf("VBoxManage updatesettings [<dir>\|<file>] [-apply]\n"
612	" [-nobackup] [-skipinvalid]\n"
613	"\n");
614	}
615
616	if (u64Cmd & USAGE_VM_STATISTICS)
617	{
618	RTPrintf("VBoxManage vmstatistics <vmname>\|<uuid> [-reset]\n"
619	" [-pattern <pattern>] [-descriptions]\n"
620	"\n");
621	}
622	}
623
624	/**
625	* Print a usage synopsis and the syntax error message.
626	*/
627	int errorSyntax(USAGECATEGORY u64Cmd, const char *pszFormat, ...)
628	{
629	va_list args;
630	showLogo(); // show logo even if suppressed
631	if (g_fInternalMode)
632	printUsageInternal(u64Cmd);
633	else
634	printUsage(u64Cmd);
635	va_start(args, pszFormat);
636	RTPrintf("\n"
637	"Syntax error: %N\n", pszFormat, &args);
638	va_end(args);
639	return 1;
640	}
641
642	/**
643	* Print an error message without the syntax stuff.
644	*/
645	int errorArgument(const char *pszFormat, ...)
646	{
647	va_list args;
648	va_start(args, pszFormat);
649	RTPrintf("error: %N\n", pszFormat, &args);
650	va_end(args);
651	return 1;
652	}
653
654	/**
655	* Print out progress on the console
656	*/
657	static void showProgress(ComPtr<IProgress> progress)
658	{
659	BOOL fCompleted;
660	LONG currentPercent;
661	LONG lastPercent = 0;
662
663	RTPrintf("0%%...");
664	RTStrmFlush(g_pStdOut);
665	while (SUCCEEDED(progress->COMGETTER(Completed(&fCompleted))))
666	{
667	progress->COMGETTER(Percent(&currentPercent));
668
669	/* did we cross a 10% mark? */
670	if (((currentPercent / 10) > (lastPercent / 10)))
671	{
672	/* make sure to also print out missed steps */
673	for (LONG curVal = (lastPercent / 10) * 10 + 10; curVal <= (currentPercent / 10) * 10; curVal += 10)
674	{
675	if (curVal < 100)
676	{
677	RTPrintf("%ld%%...", curVal);
678	RTStrmFlush(g_pStdOut);
679	}
680	}
681	lastPercent = (currentPercent / 10) * 10;
682	}
683	if (fCompleted)
684	break;
685
686	/* make sure the loop is not too tight */
687	progress->WaitForCompletion(100);
688	}
689
690	/* complete the line. */
691	HRESULT rc;
692	if (SUCCEEDED(progress->COMGETTER(ResultCode)(&rc)))
693	{
694	if (SUCCEEDED(rc))
695	RTPrintf("100%%\n");
696	else
697	RTPrintf("FAILED\n");
698	}
699	else
700	RTPrintf("\n");
701	RTStrmFlush(g_pStdOut);
702	}
703
704	static void showSnapshots(ComPtr<ISnapshot> rootSnapshot, VMINFO_DETAILS details, const Bstr &prefix = "", int level = 0)
705	{
706	/* start with the root */
707	Bstr name;
708	Guid uuid;
709	rootSnapshot->COMGETTER(Name)(name.asOutParam());
710	rootSnapshot->COMGETTER(Id)(uuid.asOutParam());
711	if (details == VMINFO_MACHINEREADABLE)
712	{
713	/* print with hierarchical numbering */
714	RTPrintf("SnapshotName%lS=\"%lS\"\n", prefix.raw(), name.raw());
715	RTPrintf("SnapshotUUID%lS=\"%s\"\n", prefix.raw(), uuid.toString().raw());
716	}
717	else
718	{
719	/* print with indentation */
720	RTPrintf(" %lSName: %lS (UUID: %s)\n", prefix.raw(), name.raw(), uuid.toString().raw());
721	}
722
723	/* get the children */
724	ComPtr<ISnapshotCollection> coll;
725	rootSnapshot->COMGETTER(Children)(coll.asOutParam());
726	if (coll)
727	{
728	ComPtr<ISnapshotEnumerator> enumerator;
729	coll->Enumerate(enumerator.asOutParam());
730	ULONG index = 0;
731	BOOL hasMore = FALSE;
732	while (enumerator->HasMore(&hasMore), hasMore)
733	{
734	ComPtr<ISnapshot> snapshot;
735	enumerator->GetNext(snapshot.asOutParam());
736	if (snapshot)
737	{
738	Bstr newPrefix;
739	if (details == VMINFO_MACHINEREADABLE)
740	newPrefix = Utf8StrFmt("%lS-%d", prefix.raw(), index + 1);
741	else
742	newPrefix = Utf8StrFmt("%lS ", prefix.raw());
743	/* recursive call */
744	showSnapshots(snapshot, details, newPrefix, level + 1);
745	}
746	index++;
747	}
748	}
749	}
750
751	static void makeTimeStr (char *s, int cb, int64_t millies)
752	{
753	RTTIME t;
754	RTTIMESPEC ts;
755
756	RTTimeSpecSetMilli(&ts, millies);
757
758	RTTimeExplode (&t, &ts);
759
760	RTStrPrintf(s, cb, "%04d/%02d/%02d %02d:%02d:%02d UTC",
761	t.i32Year, t.u8Month, t.u8MonthDay,
762	t.u8Hour, t.u8Minute, t.u8Second);
763	}
764
765	static HRESULT showVMInfo (ComPtr <IVirtualBox> virtualBox, ComPtr<IMachine> machine,
766	ComPtr <IConsole> console = ComPtr <IConsole> (),
767	VMINFO_DETAILS details = VMINFO_NONE)
768	{
769	HRESULT rc;
770
771	/*
772	* The rules for output in -argdump format:
773	* 1) the key part (the [0-9a-zA-Z_]+ string before the '=' delimiter)
774	* is all lowercase for "VBoxManage modifyvm" parameters. Any
775	* other values printed are in CamelCase.
776	* 2) strings (anything non-decimal) are printed surrounded by
777	* double quotes '"'. If the strings themselves contain double
778	* quotes, these characters are escaped by '\'. Any '\' character
779	* in the original string is also escaped by '\'.
780	* 3) numbers (containing just [0-9\-]) are written out unchanged.
781	*/
782
783	/** @todo the quoting is not yet implemented! */
784
785	BOOL accessible = FALSE;
786	CHECK_ERROR (machine, COMGETTER(Accessible) (&accessible));
787	CheckComRCReturnRC (rc);
788
789	if (!accessible)
790	{
791	if (details == VMINFO_MACHINEREADABLE)
792	RTPrintf("name=\"<inaccessible>\"\n");
793	else
794	RTPrintf ("Name: <inaccessible!>\n");
795	Guid uuid;
796	rc = machine->COMGETTER(Id) (uuid.asOutParam());
797	if (details == VMINFO_MACHINEREADABLE)
798	RTPrintf ("UUID=\"%s\"\n", uuid.toString().raw());
799	else
800	RTPrintf ("UUID: %s\n", uuid.toString().raw());
801	if (details != VMINFO_MACHINEREADABLE)
802	{
803	Bstr settingsFilePath;
804	rc = machine->COMGETTER(SettingsFilePath) (settingsFilePath.asOutParam());
805	RTPrintf ("Config file: %lS\n", settingsFilePath.raw());
806	ComPtr<IVirtualBoxErrorInfo> accessError;
807	rc = machine->COMGETTER(AccessError) (accessError.asOutParam());
808	RTPrintf ("Access error details:\n");
809	ErrorInfo ei (accessError);
810	ei.print ("[-] ");
811	RTPrintf ("\n");
812	}
813	return S_OK;
814	}
815
816	Bstr machineName;
817	rc = machine->COMGETTER(Name)(machineName.asOutParam());
818	if (details == VMINFO_MACHINEREADABLE)
819	RTPrintf("name=\"%lS\"\n", machineName.raw());
820	else
821	RTPrintf("Name: %lS\n", machineName.raw());
822
823	Bstr osTypeId;
824	rc = machine->COMGETTER(OSTypeId)(osTypeId.asOutParam());
825	ComPtr<IGuestOSType> osType;
826	rc = virtualBox->GetGuestOSType (osTypeId, osType.asOutParam());
827	Bstr osName;
828	rc = osType->COMGETTER(Description)(osName.asOutParam());
829	if (details == VMINFO_MACHINEREADABLE)
830	RTPrintf("ostype=\"%lS\"\n", osTypeId.raw());
831	else
832	RTPrintf("Guest OS: %lS\n", osName.raw());
833
834	Guid uuid;
835	rc = machine->COMGETTER(Id)(uuid.asOutParam());
836	if (details == VMINFO_MACHINEREADABLE)
837	RTPrintf("UUID=\"%s\"\n", uuid.toString().raw());
838	else
839	RTPrintf("UUID: %s\n", uuid.toString().raw());
840
841	Bstr settingsFilePath;
842	rc = machine->COMGETTER(SettingsFilePath)(settingsFilePath.asOutParam());
843	if (details == VMINFO_MACHINEREADABLE)
844	RTPrintf("CfgFile=\"%lS\"\n", settingsFilePath.raw());
845	else
846	RTPrintf("Config file: %lS\n", settingsFilePath.raw());
847
848	ULONG memorySize;
849	rc = machine->COMGETTER(MemorySize)(&memorySize);
850	if (details == VMINFO_MACHINEREADABLE)
851	RTPrintf("memory=%u\n", memorySize);
852	else
853	RTPrintf("Memory size: %uMB\n", memorySize);
854
855	ULONG vramSize;
856	rc = machine->COMGETTER(VRAMSize)(&vramSize);
857	if (details == VMINFO_MACHINEREADABLE)
858	RTPrintf("vram=%u\n", vramSize);
859	else
860	RTPrintf("VRAM size: %uMB\n", vramSize);
861
862	ComPtr <IBIOSSettings> biosSettings;
863	machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
864
865	BIOSBootMenuMode_T bootMenuMode;
866	biosSettings->COMGETTER(BootMenuMode)(&bootMenuMode);
867	const char *pszBootMenu = NULL;
868	switch (bootMenuMode)
869	{
870	case BIOSBootMenuMode_Disabled:
871	pszBootMenu = "disabled";
872	break;
873	case BIOSBootMenuMode_MenuOnly:
874	if (details == VMINFO_MACHINEREADABLE)
875	pszBootMenu = "menuonly";
876	else
877	pszBootMenu = "menu only";
878	break;
879	default:
880	if (details == VMINFO_MACHINEREADABLE)
881	pszBootMenu = "messageandmenu";
882	else
883	pszBootMenu = "message and menu";
884	}
885	if (details == VMINFO_MACHINEREADABLE)
886	RTPrintf("bootmenu=\"%s\"\n", pszBootMenu);
887	else
888	RTPrintf("Boot menu mode: %s\n", pszBootMenu);
889
890	BOOL acpiEnabled;
891	biosSettings->COMGETTER(ACPIEnabled)(&acpiEnabled);
892	if (details == VMINFO_MACHINEREADABLE)
893	RTPrintf("acpi=\"%s\"\n", acpiEnabled ? "on" : "off");
894	else
895	RTPrintf("ACPI: %s\n", acpiEnabled ? "on" : "off");
896
897	BOOL ioapicEnabled;
898	biosSettings->COMGETTER(IOAPICEnabled)(&ioapicEnabled);
899	if (details == VMINFO_MACHINEREADABLE)
900	RTPrintf("ioapic=\"%s\"\n", ioapicEnabled ? "on" : "off");
901	else
902	RTPrintf("IOAPIC: %s\n", ioapicEnabled ? "on" : "off");
903
904	LONG64 timeOffset;
905	biosSettings->COMGETTER(TimeOffset)(&timeOffset);
906	if (details == VMINFO_MACHINEREADABLE)
907	RTPrintf("biossystemtimeoffset=%lld\n", timeOffset);
908	else
909	RTPrintf("Time offset: %lld ms\n", timeOffset);
910
911	TriStateBool_T hwVirtExEnabled;
912	machine->COMGETTER(HWVirtExEnabled)(&hwVirtExEnabled);
913	if (hwVirtExEnabled == TriStateBool_TSDefault)
914	{
915	BOOL fHWVirtExEnabled;
916	ComPtr<ISystemProperties> systemProperties;
917	virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
918	systemProperties->COMGETTER(HWVirtExEnabled)(&fHWVirtExEnabled);
919	if (details == VMINFO_MACHINEREADABLE)
920	RTPrintf("hwvirtex=\"default\"\n");
921	else
922	RTPrintf("Hardw. virt.ext: Default (%s)\n", fHWVirtExEnabled ? "on" : "off");
923	}
924	else
925	{
926	if (details == VMINFO_MACHINEREADABLE)
927	RTPrintf("hwvirtex=\"%s\"\n", hwVirtExEnabled == TriStateBool_TSTrue ? "on" : "off");
928	else
929	RTPrintf("Hardw. virt.ext: %s\n", hwVirtExEnabled == TriStateBool_TSTrue ? "on" : "off");
930	}
931
932	MachineState_T machineState;
933	const char *pszState = NULL;
934	rc = machine->COMGETTER(State)(&machineState);
935	switch (machineState)
936	{
937	case MachineState_PoweredOff:
938	if (details == VMINFO_MACHINEREADABLE)
939	pszState = "poweroff";
940	else
941	pszState = "powered off";
942	break;
943	case MachineState_Saved:
944	pszState = "saved";
945	break;
946	case MachineState_Aborted:
947	pszState = "aborted";
948	break;
949	case MachineState_Running:
950	pszState = "running";
951	break;
952	case MachineState_Paused:
953	pszState = "paused";
954	break;
955	case MachineState_Starting:
956	pszState = "starting";
957	break;
958	case MachineState_Stopping:
959	pszState = "stopping";
960	break;
961	case MachineState_Saving:
962	pszState = "saving";
963	break;
964	case MachineState_Restoring:
965	pszState = "restoring";
966	break;
967	default:
968	pszState = "unknown";
969	break;
970	}
971	LONG64 stateSince;
972	machine->COMGETTER(LastStateChange)(&stateSince);
973	RTTIMESPEC timeSpec;
974	RTTimeSpecSetMilli(&timeSpec, stateSince);
975	char pszTime[30] = {0};
976	RTTimeSpecToString(&timeSpec, pszTime, 30);
977	if (details == VMINFO_MACHINEREADABLE)
978	{
979	RTPrintf("VMState=\"%s\"\n", pszState);
980	RTPrintf("VMStateChangeTime=\"%s\"\n", pszTime);
981	}
982	else
983	RTPrintf("State: %s (since %s)\n", pszState, pszTime);
984
985	ULONG numMonitors;
986	machine->COMGETTER(MonitorCount)(&numMonitors);
987	if (details == VMINFO_MACHINEREADABLE)
988	RTPrintf("monitorcount=%d\n", numMonitors);
989	else
990	RTPrintf("Monitor count: %d\n", numMonitors);
991
992	ComPtr<IFloppyDrive> floppyDrive;
993	rc = machine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
994	if (SUCCEEDED(rc) && floppyDrive)
995	{
996	BOOL fFloppyEnabled;
997	floppyDrive->COMGETTER(Enabled)(&fFloppyEnabled);
998	Utf8Str pszFloppy = "invalid";
999	if (fFloppyEnabled)
1000	{
1001	DriveState_T floppyState;
1002	floppyDrive->COMGETTER(State)(&floppyState);
1003	switch (floppyState)
1004	{
1005	case DriveState_ImageMounted:
1006	{
1007	ComPtr<IFloppyImage> floppyImage;
1008	rc = floppyDrive->GetImage(floppyImage.asOutParam());
1009	if (SUCCEEDED(rc) && floppyImage)
1010	{
1011	Bstr imagePath;
1012	floppyImage->COMGETTER(FilePath)(imagePath.asOutParam());
1013	Guid imageGuid;
1014	floppyImage->COMGETTER(Id)(imageGuid.asOutParam());
1015	if (details == VMINFO_MACHINEREADABLE)
1016	{
1017	RTPrintf("FloppyImageUUID=\"%s\"\n", imageGuid.toString().raw());
1018	pszFloppy = Utf8StrFmt("%lS", imagePath.raw());
1019	}
1020	else
1021	pszFloppy = Utf8StrFmt("%lS (UUID: %s)", imagePath.raw(), imageGuid.toString().raw());
1022	}
1023	break;
1024	}
1025
1026	case DriveState_HostDriveCaptured:
1027	{
1028	ComPtr<IHostFloppyDrive> hostFloppyDrive;
1029	rc = floppyDrive->GetHostDrive(hostFloppyDrive.asOutParam());
1030	if (SUCCEEDED(rc) && floppyDrive)
1031	{
1032	Bstr driveName;
1033	hostFloppyDrive->COMGETTER(Name)(driveName.asOutParam());
1034	if (details == VMINFO_MACHINEREADABLE)
1035	pszFloppy = Utf8StrFmt("host:%lS", driveName.raw());
1036	else
1037	pszFloppy = Utf8StrFmt("Host drive %lS", driveName.raw());
1038	}
1039	break;
1040	}
1041
1042	case DriveState_NotMounted:
1043	{
1044	pszFloppy = "empty";
1045	break;
1046	}
1047	}
1048	}
1049	else
1050	{
1051	pszFloppy = "disabled";
1052	}
1053	if (details == VMINFO_MACHINEREADABLE)
1054	RTPrintf("floppy=\"%s\"\n", pszFloppy.raw());
1055	else
1056	RTPrintf("Floppy: %s\n", pszFloppy.raw());
1057	}
1058
1059	ComPtr<IHardDisk> hardDisk;
1060	Bstr filePath;
1061	rc = machine->GetHardDisk(DiskControllerType_IDE0Controller, 0, hardDisk.asOutParam());
1062	if (SUCCEEDED(rc) && hardDisk)
1063	{
1064	/// @todo (dmik) we temporarily use the location property to
1065	// determine the image file name. This is subject to change
1066	// when iSCSI disks are here (we should either query a
1067	// storage-specific interface from IHardDisk, or "standardize"
1068	// the location property)
1069	hardDisk->COMGETTER(Location)(filePath.asOutParam());
1070	hardDisk->COMGETTER(Id)(uuid.asOutParam());
1071	if (details == VMINFO_MACHINEREADABLE)
1072	{
1073	RTPrintf("hda=\"%lS\"\n", filePath.raw());
1074	RTPrintf("HdaImageUUID=\"%s\"\n", uuid.toString().raw());
1075	}
1076	else
1077	RTPrintf("Primary master: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
1078	}
1079	else
1080	{
1081	if (details == VMINFO_MACHINEREADABLE)
1082	RTPrintf("hda=\"none\"\n");
1083	}
1084	rc = machine->GetHardDisk(DiskControllerType_IDE0Controller, 1, hardDisk.asOutParam());
1085	if (SUCCEEDED(rc) && hardDisk)
1086	{
1087	/// @todo (dmik) we temporarily use the location property to
1088	// determine the image file name. This is subject to change
1089	// when iSCSI disks are here (we should either query a
1090	// storage-specific interface from IHardDisk, or "standardize"
1091	// the location property)
1092	hardDisk->COMGETTER(Location)(filePath.asOutParam());
1093	hardDisk->COMGETTER(Id)(uuid.asOutParam());
1094	if (details == VMINFO_MACHINEREADABLE)
1095	{
1096	RTPrintf("hdb=\"%lS\"\n", filePath.raw());
1097	RTPrintf("HdbImageUUID=\"%s\"\n", uuid.toString().raw());
1098	}
1099	else
1100	RTPrintf("Primary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
1101	}
1102	else
1103	{
1104	if (details == VMINFO_MACHINEREADABLE)
1105	RTPrintf("hdb=\"none\"\n");
1106	}
1107	rc = machine->GetHardDisk(DiskControllerType_IDE1Controller, 1, hardDisk.asOutParam());
1108	if (SUCCEEDED(rc) && hardDisk)
1109	{
1110	/// @todo (dmik) we temporarily use the location property to
1111	// determine the image file name. This is subject to change
1112	// when iSCSI disks are here (we should either query a
1113	// storage-specific interface from IHardDisk, or "standardize"
1114	// the location property)
1115	hardDisk->COMGETTER(Location)(filePath.asOutParam());
1116	hardDisk->COMGETTER(Id)(uuid.asOutParam());
1117	if (details == VMINFO_MACHINEREADABLE)
1118	{
1119	RTPrintf("hdd=\"%lS\"\n", filePath.raw());
1120	RTPrintf("HddImageUUID=\"%s\"\n", uuid.toString().raw());
1121	}
1122	else
1123	RTPrintf("Secondary slave: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
1124	}
1125	else
1126	{
1127	if (details == VMINFO_MACHINEREADABLE)
1128	RTPrintf("hdd=\"none\"\n");
1129	}
1130	ComPtr<IDVDDrive> dvdDrive;
1131	rc = machine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
1132	if (SUCCEEDED(rc) && dvdDrive)
1133	{
1134	ComPtr<IDVDImage> dvdImage;
1135	rc = dvdDrive->GetImage(dvdImage.asOutParam());
1136	if (SUCCEEDED(rc) && dvdImage)
1137	{
1138	rc = dvdImage->COMGETTER(FilePath)(filePath.asOutParam());
1139	if (SUCCEEDED(rc) && filePath)
1140	{
1141	rc = dvdImage->COMGETTER(Id)(uuid.asOutParam());
1142	if (details == VMINFO_MACHINEREADABLE)
1143	{
1144	RTPrintf("dvd=\"%lS\"\n", filePath.raw());
1145	RTPrintf("DvdImageUUID=\"%s\"\n", uuid.toString().raw());
1146	}
1147	else
1148	RTPrintf("DVD: %lS (UUID: %s)\n", filePath.raw(), uuid.toString().raw());
1149	}
1150	}
1151	else
1152	{
1153	ComPtr<IHostDVDDrive> hostDVDDrive;
1154	rc = dvdDrive->GetHostDrive(hostDVDDrive.asOutParam());
1155	if (SUCCEEDED(rc) && hostDVDDrive)
1156	{
1157	Bstr name;
1158	hostDVDDrive->COMGETTER(Name)(name.asOutParam());
1159	if (details == VMINFO_MACHINEREADABLE)
1160	RTPrintf("dvd=\"host:%lS\"\n", name.raw());
1161	else
1162	RTPrintf("DVD: Host drive %lS", name.raw());
1163	}
1164	else
1165	{
1166	if (details == VMINFO_MACHINEREADABLE)
1167	RTPrintf("dvd=\"none\"\n");
1168	else
1169	RTPrintf("DVD: empty");
1170	}
1171	BOOL fPassthrough;
1172	dvdDrive->COMGETTER(Passthrough)(&fPassthrough);
1173	if (details == VMINFO_MACHINEREADABLE)
1174	{
1175	RTPrintf("dvdpassthrough=\"%s\"\n", fPassthrough ? "on" : "off");
1176	}
1177	else
1178	{
1179	if (fPassthrough)
1180	RTPrintf(" (passthrough enabled)");
1181	RTPrintf("\n");
1182	}
1183	}
1184	}
1185
1186	/* get the maximum amount of NICS */
1187	ComPtr<ISystemProperties> sysProps;
1188	virtualBox->COMGETTER(SystemProperties)(sysProps.asOutParam());
1189	ULONG maxNICs = 0;
1190	sysProps->COMGETTER(NetworkAdapterCount)(&maxNICs);
1191	for (ULONG currentNIC = 0; currentNIC < maxNICs; currentNIC++)
1192	{
1193	ComPtr<INetworkAdapter> nic;
1194	rc = machine->GetNetworkAdapter(currentNIC, nic.asOutParam());
1195	if (SUCCEEDED(rc) && nic)
1196	{
1197	BOOL fEnabled;
1198	nic->COMGETTER(Enabled)(&fEnabled);
1199	if (!fEnabled)
1200	{
1201	if (details == VMINFO_MACHINEREADABLE)
1202	RTPrintf("nic%d=\"none\"\n", currentNIC + 1);
1203	else
1204	RTPrintf("NIC %d: disabled\n", currentNIC + 1);
1205	}
1206	else
1207	{
1208	Bstr strMACAddress;
1209	nic->COMGETTER(MACAddress)(strMACAddress.asOutParam());
1210	Utf8Str strAttachment;
1211	NetworkAttachmentType_T attachment;
1212	nic->COMGETTER(AttachmentType)(&attachment);
1213	switch (attachment)
1214	{
1215	case NetworkAttachmentType_NoNetworkAttachment:
1216	if (details == VMINFO_MACHINEREADABLE)
1217	strAttachment = "null";
1218	else
1219	strAttachment = "none";
1220	break;
1221	case NetworkAttachmentType_NATNetworkAttachment:
1222	if (details == VMINFO_MACHINEREADABLE)
1223	strAttachment = "nat";
1224	else
1225	strAttachment = "NAT";
1226	break;
1227	case NetworkAttachmentType_HostInterfaceNetworkAttachment:
1228	{
1229	Bstr strHostIfDev;
1230	nic->COMGETTER(HostInterface)(strHostIfDev.asOutParam());
1231	if (details == VMINFO_MACHINEREADABLE)
1232	{
1233	RTPrintf("hostifdev%d=\"%lS\"\n", currentNIC + 1, strHostIfDev.raw());
1234	strAttachment = "hostif";
1235	}
1236	else
1237	strAttachment = Utf8StrFmt("Host Interface '%lS'", strHostIfDev.raw());
1238	break;
1239	}
1240	case NetworkAttachmentType_InternalNetworkAttachment:
1241	{
1242	Bstr strNetwork;
1243	nic->COMGETTER(InternalNetwork)(strNetwork.asOutParam());
1244	if (details == VMINFO_MACHINEREADABLE)
1245	{
1246	RTPrintf("intnet%d=\"%lS\"\n", currentNIC + 1, strNetwork.raw());
1247	strAttachment = "intnet";
1248	}
1249	else
1250	strAttachment = Utf8StrFmt("Internal Network '%s'", Utf8Str(strNetwork).raw());
1251	break;
1252	}
1253	default:
1254	strAttachment = "unknown";
1255	break;
1256	}
1257
1258	/* cable connected */
1259	BOOL fConnected;
1260	nic->COMGETTER(CableConnected)(&fConnected);
1261
1262	/* trace stuff */
1263	BOOL fTraceEnabled;
1264	nic->COMGETTER(TraceEnabled)(&fTraceEnabled);
1265	Bstr traceFile;
1266	nic->COMGETTER(TraceFile)(traceFile.asOutParam());
1267
1268	/* NIC type */
1269	Utf8Str strNICType;
1270	NetworkAdapterType_T NICType;
1271	nic->COMGETTER(AdapterType)(&NICType);
1272	switch (NICType) {
1273	case NetworkAdapterType_NetworkAdapterAm79C970A:
1274	strNICType = "Am79C970A";
1275	break;
1276	case NetworkAdapterType_NetworkAdapterAm79C973:
1277	strNICType = "Am79C973";
1278	break;
1279	default:
1280	strNICType = "unknown";
1281	break;
1282	}
1283
1284	/* reported line speed */
1285	ULONG ulLineSpeed;
1286	nic->COMGETTER(LineSpeed)(&ulLineSpeed);
1287
1288	if (details == VMINFO_MACHINEREADABLE)
1289	{
1290	RTPrintf("macaddress%d=\"%lS\"\n", currentNIC + 1, strMACAddress.raw());
1291	RTPrintf("cableconnected%d=\"%s\"\n", currentNIC + 1, fConnected ? "on" : "off");
1292	RTPrintf("nic%d=\"%s\"\n", currentNIC + 1, strAttachment.raw());
1293	}
1294	else
1295	RTPrintf("NIC %d: MAC: %lS, Attachment: %s, Cable connected: %s, Trace: %s (file: %lS), Type: %s, Reported speed: %d Mbps\n",
1296	currentNIC + 1, strMACAddress.raw(), strAttachment.raw(),
1297	fConnected ? "on" : "off",
1298	fTraceEnabled ? "on" : "off", traceFile.raw(),
1299	strNICType.raw(),
1300	ulLineSpeed / 1000);
1301	}
1302	}
1303	}
1304
1305	/* get the maximum amount of UARTs */
1306	ULONG maxUARTs = 0;
1307	sysProps->COMGETTER(SerialPortCount)(&maxUARTs);
1308	for (ULONG currentUART = 0; currentUART < maxUARTs; currentUART++)
1309	{
1310	ComPtr<ISerialPort> uart;
1311	rc = machine->GetSerialPort(currentUART, uart.asOutParam());
1312	if (SUCCEEDED(rc) && uart)
1313	{
1314	BOOL fEnabled;
1315	uart->COMGETTER(Enabled)(&fEnabled);
1316	if (!fEnabled)
1317	{
1318	if (details == VMINFO_MACHINEREADABLE)
1319	RTPrintf("uart%d=\"off\"\n", currentUART + 1);
1320	else
1321	RTPrintf("UART %d: disabled\n", currentUART + 1);
1322	}
1323	else
1324	{
1325	ULONG ulIRQ, ulIOBase;
1326	PortMode_T HostMode;
1327	Bstr path;
1328	BOOL fServer;
1329	uart->COMGETTER(IRQ)(&ulIRQ);
1330	uart->COMGETTER(IOBase)(&ulIOBase);
1331	uart->COMGETTER(Path)(path.asOutParam());
1332	uart->COMGETTER(Server)(&fServer);
1333	uart->COMGETTER(HostMode)(&HostMode);
1334
1335	if (details == VMINFO_MACHINEREADABLE)
1336	RTPrintf("uart%d=\"%#06x,%d\"\n", currentUART + 1,
1337	ulIOBase, ulIRQ);
1338	else
1339	RTPrintf("UART %d: I/O base: 0x%04x, IRQ: %d",
1340	currentUART + 1, ulIOBase, ulIRQ);
1341	switch (HostMode)
1342	{
1343	default:
1344	case PortMode_DisconnectedPort:
1345	if (details == VMINFO_MACHINEREADABLE)
1346	RTPrintf("uartmode%d=\"disconnected\"\n", currentUART + 1);
1347	else
1348	RTPrintf(", disconnected\n");
1349	break;
1350	case PortMode_HostPipePort:
1351	if (details == VMINFO_MACHINEREADABLE)
1352	RTPrintf("uartmode%d=\"%s,%lS\"\n", currentUART + 1,
1353	fServer ? "server" : "client", path.raw());
1354	else
1355	RTPrintf(", attached to pipe (%s) '%lS'\n",
1356	fServer ? "server" : "client", path.raw());
1357	break;
1358	case PortMode_HostDevicePort:
1359	if (details == VMINFO_MACHINEREADABLE)
1360	RTPrintf("uartmode%d=\"%lS\"\n", currentUART + 1,
1361	path.raw());
1362	else
1363	RTPrintf(", attached to device '%lS'\n", path.raw());
1364	break;
1365	}
1366	}
1367	}
1368	}
1369
1370	ComPtr<IAudioAdapter> AudioAdapter;
1371	rc = machine->COMGETTER(AudioAdapter)(AudioAdapter.asOutParam());
1372	if (SUCCEEDED(rc))
1373	{
1374	const char *pszDrv = "Unknown";
1375	const char *pszCtrl = "Unknown";
1376	BOOL fEnabled;
1377	rc = AudioAdapter->COMGETTER(Enabled)(&fEnabled);
1378	if (SUCCEEDED(rc) && fEnabled)
1379	{
1380	AudioDriverType_T enmDrvType;
1381	rc = AudioAdapter->COMGETTER(AudioDriver)(&enmDrvType);
1382	switch (enmDrvType)
1383	{
1384	case AudioDriverType_NullAudioDriver:
1385	if (details == VMINFO_MACHINEREADABLE)
1386	pszDrv = "null";
1387	else
1388	pszDrv = "Null";
1389	break;
1390	case AudioDriverType_WINMMAudioDriver:
1391	if (details == VMINFO_MACHINEREADABLE)
1392	pszDrv = "winmm";
1393	else
1394	pszDrv = "WINMM";
1395	break;
1396	case AudioDriverType_DSOUNDAudioDriver:
1397	if (details == VMINFO_MACHINEREADABLE)
1398	pszDrv = "dsound";
1399	else
1400	pszDrv = "DSOUND";
1401	break;
1402	case AudioDriverType_OSSAudioDriver:
1403	if (details == VMINFO_MACHINEREADABLE)
1404	pszDrv = "oss";
1405	else
1406	pszDrv = "OSS";
1407	break;
1408	case AudioDriverType_ALSAAudioDriver:
1409	if (details == VMINFO_MACHINEREADABLE)
1410	pszDrv = "alsa";
1411	else
1412	pszDrv = "ALSA";
1413	break;
1414	case AudioDriverType_PulseAudioDriver:
1415	if (details == VMINFO_MACHINEREADABLE)
1416	pszDrv = "pulse";
1417	else
1418	pszDrv = "PulseAudio";
1419	break;
1420	case AudioDriverType_CoreAudioDriver:
1421	if (details == VMINFO_MACHINEREADABLE)
1422	pszDrv = "coreaudio";
1423	else
1424	pszDrv = "CoreAudio";
1425	break;
1426	default:
1427	if (details == VMINFO_MACHINEREADABLE)
1428	pszDrv = "unknown";
1429	break;
1430	}
1431	AudioControllerType_T enmCtrlType;
1432	rc = AudioAdapter->COMGETTER(AudioController)(&enmCtrlType);
1433	switch (enmCtrlType)
1434	{
1435	case AudioControllerType_AC97:
1436	if (details == VMINFO_MACHINEREADABLE)
1437	pszCtrl = "ac97";
1438	else
1439	pszCtrl = "AC97";
1440	break;
1441	case AudioControllerType_SB16:
1442	if (details == VMINFO_MACHINEREADABLE)
1443	pszCtrl = "sb16";
1444	else
1445	pszCtrl = "SB16";
1446	break;
1447	}
1448	}
1449	else
1450	fEnabled = FALSE;
1451	if (details == VMINFO_MACHINEREADABLE)
1452	{
1453	if (fEnabled)
1454	RTPrintf("audio=\"%s\"\n", pszDrv);
1455	else
1456	RTPrintf("audio=\"none\"\n");
1457	}
1458	else
1459	RTPrintf("Audio: %s (Driver: %s, Controller: %s)\n",
1460	fEnabled ? "enabled" : "disabled", pszDrv, pszCtrl);
1461	}
1462
1463	/* Shared clipboard */
1464	{
1465	const char *psz = "Unknown";
1466	ClipboardMode_T enmMode;
1467	rc = machine->COMGETTER(ClipboardMode)(&enmMode);
1468	switch (enmMode)
1469	{
1470	case ClipboardMode_ClipDisabled:
1471	if (details == VMINFO_MACHINEREADABLE)
1472	psz = "disabled";
1473	else
1474	psz = "disabled";
1475	break;
1476	case ClipboardMode_ClipHostToGuest:
1477	if (details == VMINFO_MACHINEREADABLE)
1478	psz = "hosttoguest";
1479	else
1480	psz = "HostToGuest";
1481	break;
1482	case ClipboardMode_ClipGuestToHost:
1483	if (details == VMINFO_MACHINEREADABLE)
1484	psz = "guesttohost";
1485	else
1486	psz = "GuestToHost";
1487	break;
1488	case ClipboardMode_ClipBidirectional:
1489	if (details == VMINFO_MACHINEREADABLE)
1490	psz = "bidirectional";
1491	else
1492	psz = "Bidirectional";
1493	break;
1494	default:
1495	if (details == VMINFO_MACHINEREADABLE)
1496	psz = "unknown";
1497	break;
1498	}
1499	if (details == VMINFO_MACHINEREADABLE)
1500	RTPrintf("clipboard=\"%s\"\n", psz);
1501	else
1502	RTPrintf("Clipboard Mode: %s\n", psz);
1503	}
1504
1505	if (console)
1506	{
1507	ComPtr<IDisplay> display;
1508	CHECK_ERROR_RET(console, COMGETTER(Display)(display.asOutParam()), rc);
1509	ULONG xRes, yRes, bpp;
1510	CHECK_ERROR_RET(display, COMGETTER(Width)(&xRes), rc);
1511	CHECK_ERROR_RET(display, COMGETTER(Height)(&yRes), rc);
1512	CHECK_ERROR_RET(display, COMGETTER(BitsPerPixel)(&bpp), rc);
1513	if (details == VMINFO_MACHINEREADABLE)
1514	RTPrintf("VideoMode=\"%d,%d,%d\"\n", xRes, yRes, bpp);
1515	else
1516	RTPrintf("Video mode: %dx%dx%d\n", xRes, yRes, bpp);
1517	}
1518
1519	/*
1520	* VRDP
1521	*/
1522	ComPtr<IVRDPServer> vrdpServer;
1523	rc = machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
1524	if (SUCCEEDED(rc) && vrdpServer)
1525	{
1526	BOOL fEnabled = false;
1527	vrdpServer->COMGETTER(Enabled)(&fEnabled);
1528	if (fEnabled)
1529	{
1530	ULONG port;
1531	vrdpServer->COMGETTER(Port)(&port);
1532	Bstr address;
1533	vrdpServer->COMGETTER(NetAddress)(address.asOutParam());
1534	BOOL fMultiCon;
1535	vrdpServer->COMGETTER(AllowMultiConnection)(&fMultiCon);
1536	VRDPAuthType_T vrdpAuthType;
1537	const char *strAuthType;
1538	vrdpServer->COMGETTER(AuthType)(&vrdpAuthType);
1539	switch (vrdpAuthType)
1540	{
1541	case VRDPAuthType_VRDPAuthNull:
1542	strAuthType = "null";
1543	break;
1544	case VRDPAuthType_VRDPAuthExternal:
1545	strAuthType = "external";
1546	break;
1547	case VRDPAuthType_VRDPAuthGuest:
1548	strAuthType = "guest";
1549	break;
1550	default:
1551	strAuthType = "unknown";
1552	break;
1553	}
1554	if (details == VMINFO_MACHINEREADABLE)
1555	{
1556	RTPrintf("vrdp=\"on\"\n");
1557	RTPrintf("vrdpport=%d\n", port);
1558	RTPrintf("vrdpaddress=\"%lS\"\n", address.raw());
1559	RTPrintf("vrdpauthtype=\"%s\"\n", strAuthType);
1560	RTPrintf("vrdpmulticon=\"%s\"\n", fMultiCon ? "on" : "off");
1561	}
1562	else
1563	{
1564	if (address.isEmpty())
1565	address = "0.0.0.0";
1566	RTPrintf("VRDP: enabled (Address %lS, Port %d, MultiConn: %s, Authentication type: %s)\n", address.raw(), port, fMultiCon ? "on" : "off", strAuthType);
1567	}
1568	}
1569	else
1570	{
1571	if (details == VMINFO_MACHINEREADABLE)
1572	RTPrintf("vrdp=\"off\"\n");
1573	else
1574	RTPrintf("VRDP: disabled\n");
1575	}
1576	}
1577
1578	/*
1579	* USB.
1580	*/
1581	ComPtr<IUSBController> USBCtl;
1582	rc = machine->COMGETTER(USBController)(USBCtl.asOutParam());
1583	if (SUCCEEDED(rc))
1584	{
1585	BOOL fEnabled;
1586	rc = USBCtl->COMGETTER(Enabled)(&fEnabled);
1587	if (FAILED(rc))
1588	fEnabled = false;
1589	if (details == VMINFO_MACHINEREADABLE)
1590	RTPrintf("usb=\"%s\"\n", fEnabled ? "on" : "off");
1591	else
1592	RTPrintf("USB: %s\n", fEnabled ? "enabled" : "disabled");
1593
1594	if (details != VMINFO_MACHINEREADABLE)
1595	RTPrintf("\nUSB Device Filters:\n\n");
1596
1597	ComPtr<IUSBDeviceFilterCollection> Coll;
1598	CHECK_ERROR_RET (USBCtl, COMGETTER(DeviceFilters)(Coll.asOutParam()), rc);
1599
1600	ComPtr<IUSBDeviceFilterEnumerator> Enum;
1601	CHECK_ERROR_RET (Coll, Enumerate(Enum.asOutParam()), rc);
1602
1603	ULONG index = 0;
1604	BOOL fMore = FALSE;
1605	rc = Enum->HasMore (&fMore);
1606	ASSERT_RET (SUCCEEDED (rc), rc);
1607
1608	if (!fMore)
1609	{
1610	if (details != VMINFO_MACHINEREADABLE)
1611	RTPrintf("<none>\n\n");
1612	}
1613	else
1614	while (fMore)
1615	{
1616	ComPtr<IUSBDeviceFilter> DevPtr;
1617	rc = Enum->GetNext(DevPtr.asOutParam());
1618	ASSERT_RET (SUCCEEDED (rc), rc);
1619
1620	/* Query info. */
1621
1622	if (details != VMINFO_MACHINEREADABLE)
1623	RTPrintf("Index: %lu\n", index);
1624
1625	BOOL bActive = FALSE;
1626	CHECK_ERROR_RET (DevPtr, COMGETTER (Active) (&bActive), rc);
1627	if (details == VMINFO_MACHINEREADABLE)
1628	RTPrintf("USBFilterActive%d=\"%s\"\n", index + 1, bActive ? "on" : "off");
1629	else
1630	RTPrintf("Active: %s\n", bActive ? "yes" : "no");
1631
1632	Bstr bstr;
1633	CHECK_ERROR_RET (DevPtr, COMGETTER (Name) (bstr.asOutParam()), rc);
1634	if (details == VMINFO_MACHINEREADABLE)
1635	RTPrintf("USBFilterName%d=\"%lS\"\n", index + 1, bstr.raw());
1636	else
1637	RTPrintf("Name: %lS\n", bstr.raw());
1638	CHECK_ERROR_RET (DevPtr, COMGETTER (VendorId) (bstr.asOutParam()), rc);
1639	if (details == VMINFO_MACHINEREADABLE)
1640	RTPrintf("USBFilterVendorId%d=\"%lS\"\n", index + 1, bstr.raw());
1641	else
1642	RTPrintf("VendorId: %lS\n", bstr.raw());
1643	CHECK_ERROR_RET (DevPtr, COMGETTER (ProductId) (bstr.asOutParam()), rc);
1644	if (details == VMINFO_MACHINEREADABLE)
1645	RTPrintf("USBFilterProductId%d=\"%lS\"\n", index + 1, bstr.raw());
1646	else
1647	RTPrintf("ProductId: %lS\n", bstr.raw());
1648	CHECK_ERROR_RET (DevPtr, COMGETTER (Revision) (bstr.asOutParam()), rc);
1649	if (details == VMINFO_MACHINEREADABLE)
1650	RTPrintf("USBFilterRevision%d=\"%lS\"\n", index + 1, bstr.raw());
1651	else
1652	RTPrintf("Revision: %lS\n", bstr.raw());
1653	CHECK_ERROR_RET (DevPtr, COMGETTER (Manufacturer) (bstr.asOutParam()), rc);
1654	if (details == VMINFO_MACHINEREADABLE)
1655	RTPrintf("USBFilterManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());
1656	else
1657	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1658	CHECK_ERROR_RET (DevPtr, COMGETTER (Product) (bstr.asOutParam()), rc);
1659	if (details == VMINFO_MACHINEREADABLE)
1660	RTPrintf("USBFilterProduct%d=\"%lS\"\n", index + 1, bstr.raw());
1661	else
1662	RTPrintf("Product: %lS\n", bstr.raw());
1663	CHECK_ERROR_RET (DevPtr, COMGETTER (Remote) (bstr.asOutParam()), rc);
1664	if (details == VMINFO_MACHINEREADABLE)
1665	RTPrintf("USBFilterRemote%d=\"%lS\"\n", index + 1, bstr.raw());
1666	else
1667	RTPrintf("Remote: %lS\n", bstr.raw());
1668	CHECK_ERROR_RET (DevPtr, COMGETTER (SerialNumber) (bstr.asOutParam()), rc);
1669	if (details == VMINFO_MACHINEREADABLE)
1670	RTPrintf("USBFilterSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());
1671	else
1672	RTPrintf("Serial Number: %lS\n", bstr.raw());
1673	if (details != VMINFO_MACHINEREADABLE)
1674	{
1675	ULONG fMaskedIfs;
1676	CHECK_ERROR_RET (DevPtr, COMGETTER (MaskedInterfaces) (&fMaskedIfs), rc);
1677	if (fMaskedIfs)
1678	RTPrintf("Masked Interfaces: 0x%08x\n", fMaskedIfs);
1679	RTPrintf("\n");
1680	}
1681
1682	rc = Enum->HasMore (&fMore);
1683	ASSERT_RET (SUCCEEDED (rc), rc);
1684
1685	index ++;
1686	}
1687
1688	if (console)
1689	{
1690	index = 0;
1691	/* scope */
1692	{
1693	if (details != VMINFO_MACHINEREADABLE)
1694	RTPrintf("Available remote USB devices:\n\n");
1695
1696	ComPtr<IHostUSBDeviceCollection> coll;
1697	CHECK_ERROR_RET (console, COMGETTER(RemoteUSBDevices) (coll.asOutParam()), rc);
1698
1699	ComPtr <IHostUSBDeviceEnumerator> en;
1700	CHECK_ERROR_RET (coll, Enumerate (en.asOutParam()), rc);
1701
1702	BOOL more = FALSE;
1703	rc = en->HasMore (&more);
1704	ASSERT_RET (SUCCEEDED (rc), rc);
1705
1706	if (!more)
1707	{
1708	if (details != VMINFO_MACHINEREADABLE)
1709	RTPrintf("<none>\n\n");
1710	}
1711	else
1712	while (more)
1713	{
1714	ComPtr <IHostUSBDevice> dev;
1715	rc = en->GetNext (dev.asOutParam());
1716	ASSERT_RET (SUCCEEDED (rc), rc);
1717
1718	/* Query info. */
1719	Guid id;
1720	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1721	USHORT usVendorId;
1722	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1723	USHORT usProductId;
1724	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1725	USHORT bcdRevision;
1726	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1727
1728	if (details == VMINFO_MACHINEREADABLE)
1729	RTPrintf("USBRemoteUUID%d=\"%S\"\n"
1730	"USBRemoteVendorId%d=\"%#06x\"\n"
1731	"USBRemoteProductId%d=\"%#06x\"\n"
1732	"USBRemoteRevision%d=\"%#04x%02x\"\n",
1733	index + 1, id.toString().raw(),
1734	index + 1, usVendorId,
1735	index + 1, usProductId,
1736	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1737	else
1738	RTPrintf("UUID: %S\n"
1739	"VendorId: 0x%04x (%04X)\n"
1740	"ProductId: 0x%04x (%04X)\n"
1741	"Revision: %u.%u (%02u%02u)\n",
1742	id.toString().raw(),
1743	usVendorId, usVendorId, usProductId, usProductId,
1744	bcdRevision >> 8, bcdRevision & 0xff,
1745	bcdRevision >> 8, bcdRevision & 0xff);
1746
1747	/* optional stuff. */
1748	Bstr bstr;
1749	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1750	if (!bstr.isEmpty())
1751	{
1752	if (details == VMINFO_MACHINEREADABLE)
1753	RTPrintf("USBRemoteManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());
1754	else
1755	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1756	}
1757	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1758	if (!bstr.isEmpty())
1759	{
1760	if (details == VMINFO_MACHINEREADABLE)
1761	RTPrintf("USBRemoteProduct%d=\"%lS\"\n", index + 1, bstr.raw());
1762	else
1763	RTPrintf("Product: %lS\n", bstr.raw());
1764	}
1765	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1766	if (!bstr.isEmpty())
1767	{
1768	if (details == VMINFO_MACHINEREADABLE)
1769	RTPrintf("USBRemoteSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());
1770	else
1771	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1772	}
1773	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1774	if (!bstr.isEmpty())
1775	{
1776	if (details == VMINFO_MACHINEREADABLE)
1777	RTPrintf("USBRemoteAddress%d=\"%lS\"\n", index + 1, bstr.raw());
1778	else
1779	RTPrintf("Address: %lS\n", bstr.raw());
1780	}
1781
1782	if (details != VMINFO_MACHINEREADABLE)
1783	RTPrintf("\n");
1784
1785	rc = en->HasMore (&more);
1786	ASSERT_RET (SUCCEEDED (rc), rc);
1787
1788	index ++;
1789	}
1790	}
1791
1792	index = 0;
1793	/* scope */
1794	{
1795	if (details != VMINFO_MACHINEREADABLE)
1796	RTPrintf ("Currently Attached USB Devices:\n\n");
1797
1798	ComPtr <IUSBDeviceCollection> coll;
1799	CHECK_ERROR_RET (console, COMGETTER(USBDevices) (coll.asOutParam()), rc);
1800
1801	ComPtr <IUSBDeviceEnumerator> en;
1802	CHECK_ERROR_RET (coll, Enumerate (en.asOutParam()), rc);
1803
1804	BOOL more = FALSE;
1805	rc = en->HasMore (&more);
1806	ASSERT_RET (SUCCEEDED (rc), rc);
1807
1808	if (!more)
1809	{
1810	if (details != VMINFO_MACHINEREADABLE)
1811	RTPrintf("<none>\n\n");
1812	}
1813	else
1814	while (more)
1815	{
1816	ComPtr <IUSBDevice> dev;
1817	rc = en->GetNext (dev.asOutParam());
1818	ASSERT_RET (SUCCEEDED (rc), rc);
1819
1820	/* Query info. */
1821	Guid id;
1822	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), rc);
1823	USHORT usVendorId;
1824	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), rc);
1825	USHORT usProductId;
1826	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), rc);
1827	USHORT bcdRevision;
1828	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), rc);
1829
1830	if (details == VMINFO_MACHINEREADABLE)
1831	RTPrintf("USBAttachedUUID%d=\"%S\"\n"
1832	"USBAttachedVendorId%d=\"%#06x\"\n"
1833	"USBAttachedProductId%d=\"%#06x\"\n"
1834	"USBAttachedRevision%d=\"%#04x%02x\"\n",
1835	index + 1, id.toString().raw(),
1836	index + 1, usVendorId,
1837	index + 1, usProductId,
1838	index + 1, bcdRevision >> 8, bcdRevision & 0xff);
1839	else
1840	RTPrintf("UUID: %S\n"
1841	"VendorId: 0x%04x (%04X)\n"
1842	"ProductId: 0x%04x (%04X)\n"
1843	"Revision: %u.%u (%02u%02u)\n",
1844	id.toString().raw(),
1845	usVendorId, usVendorId, usProductId, usProductId,
1846	bcdRevision >> 8, bcdRevision & 0xff,
1847	bcdRevision >> 8, bcdRevision & 0xff);
1848
1849	/* optional stuff. */
1850	Bstr bstr;
1851	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), rc);
1852	if (!bstr.isEmpty())
1853	{
1854	if (details == VMINFO_MACHINEREADABLE)
1855	RTPrintf("USBAttachedManufacturer%d=\"%lS\"\n", index + 1, bstr.raw());
1856	else
1857	RTPrintf("Manufacturer: %lS\n", bstr.raw());
1858	}
1859	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), rc);
1860	if (!bstr.isEmpty())
1861	{
1862	if (details == VMINFO_MACHINEREADABLE)
1863	RTPrintf("USBAttachedProduct%d=\"%lS\"\n", index + 1, bstr.raw());
1864	else
1865	RTPrintf("Product: %lS\n", bstr.raw());
1866	}
1867	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), rc);
1868	if (!bstr.isEmpty())
1869	{
1870	if (details == VMINFO_MACHINEREADABLE)
1871	RTPrintf("USBAttachedSerialNumber%d=\"%lS\"\n", index + 1, bstr.raw());
1872	else
1873	RTPrintf("SerialNumber: %lS\n", bstr.raw());
1874	}
1875	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), rc);
1876	if (!bstr.isEmpty())
1877	{
1878	if (details == VMINFO_MACHINEREADABLE)
1879	RTPrintf("USBAttachedAddress%d=\"%lS\"\n", index + 1, bstr.raw());
1880	else
1881	RTPrintf("Address: %lS\n", bstr.raw());
1882	}
1883
1884	if (details != VMINFO_MACHINEREADABLE)
1885	RTPrintf("\n");
1886
1887	rc = en->HasMore (&more);
1888	ASSERT_RET (SUCCEEDED (rc), rc);
1889
1890	index ++;
1891	}
1892	}
1893	}
1894	} /* USB */
1895
1896	/*
1897	* Shared folders
1898	*/
1899	if (details != VMINFO_MACHINEREADABLE)
1900	RTPrintf("Shared folders: ");
1901	uint32_t numSharedFolders = 0;
1902	#if 0 // not yet implemented
1903	/* globally shared folders first */
1904	{
1905	ComPtr<ISharedFolderCollection> sfColl;
1906	ComPtr<ISharedFolderEnumerator> sfEnum;
1907	CHECK_ERROR_RET(virtualBox, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);
1908	CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);
1909	BOOL fMore;
1910	sfEnum->HasMore(&fMore);
1911	while (fMore)
1912	{
1913	ComPtr<ISharedFolder> sf;
1914	CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);
1915	Bstr name, hostPath;
1916	sf->COMGETTER(Name)(name.asOutParam());
1917	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1918	RTPrintf("Name: '%lS', Host path: '%lS' (global mapping)\n", name.raw(), hostPath.raw());
1919	++numSharedFolders;
1920	CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);
1921	}
1922	}
1923	#endif
1924	/* now VM mappings */
1925	{
1926	ComPtr<ISharedFolderCollection> sfColl;
1927	ComPtr<ISharedFolderEnumerator> sfEnum;
1928	CHECK_ERROR_RET(machine, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);
1929	CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);
1930	ULONG index = 0;
1931	BOOL fMore;
1932	sfEnum->HasMore(&fMore);
1933	while (fMore)
1934	{
1935	ComPtr<ISharedFolder> sf;
1936	CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);
1937	Bstr name, hostPath;
1938	BOOL writable;
1939	sf->COMGETTER(Name)(name.asOutParam());
1940	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1941	sf->COMGETTER(Writable)(&writable);
1942	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1943	RTPrintf("\n\n");
1944	if (details == VMINFO_MACHINEREADABLE)
1945	{
1946	RTPrintf("SharedFolderNameMachineMapping%d=\"%lS\"\n", index + 1,
1947	name.raw());
1948	RTPrintf("SharedFolderPathMachineMapping%d=\"%lS\"\n", index + 1,
1949	hostPath.raw());
1950	}
1951	else
1952	RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
1953	name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
1954	++numSharedFolders;
1955	CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);
1956	}
1957	}
1958	/* transient mappings */
1959	if (console)
1960	{
1961	ComPtr<ISharedFolderCollection> sfColl;
1962	ComPtr<ISharedFolderEnumerator> sfEnum;
1963	CHECK_ERROR_RET(console, COMGETTER(SharedFolders)(sfColl.asOutParam()), rc);
1964	CHECK_ERROR_RET(sfColl, Enumerate(sfEnum.asOutParam()), rc);
1965	ULONG index = 0;
1966	BOOL fMore;
1967	sfEnum->HasMore(&fMore);
1968	while (fMore)
1969	{
1970	ComPtr<ISharedFolder> sf;
1971	CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);
1972	Bstr name, hostPath;
1973	sf->COMGETTER(Name)(name.asOutParam());
1974	sf->COMGETTER(HostPath)(hostPath.asOutParam());
1975	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1976	RTPrintf("\n\n");
1977	if (details == VMINFO_MACHINEREADABLE)
1978	{
1979	RTPrintf("SharedFolderNameTransientMapping%d=\"%lS\"\n", index + 1,
1980	name.raw());
1981	RTPrintf("SharedFolderPathTransientMapping%d=\"%lS\"\n", index + 1,
1982	hostPath.raw());
1983	}
1984	else
1985	RTPrintf("Name: '%lS', Host path: '%lS' (transient mapping)\n", name.raw(), hostPath.raw());
1986	++numSharedFolders;
1987	CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);
1988	}
1989	}
1990	if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
1991	RTPrintf("<none>\n");
1992	if (details != VMINFO_MACHINEREADABLE)
1993	RTPrintf("\n");
1994
1995	if (console)
1996	{
1997	/*
1998	* Live VRDP info.
1999	*/
2000	ComPtr<IRemoteDisplayInfo> remoteDisplayInfo;
2001	CHECK_ERROR_RET(console, COMGETTER(RemoteDisplayInfo)(remoteDisplayInfo.asOutParam()), rc);
2002	BOOL Active;
2003	ULONG NumberOfClients;
2004	LONG64 BeginTime;
2005	LONG64 EndTime;
2006	ULONG64 BytesSent;
2007	ULONG64 BytesSentTotal;
2008	ULONG64 BytesReceived;
2009	ULONG64 BytesReceivedTotal;
2010	Bstr User;
2011	Bstr Domain;
2012	Bstr ClientName;
2013	Bstr ClientIP;
2014	ULONG ClientVersion;
2015	ULONG EncryptionStyle;
2016
2017	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Active) (&Active), rc);
2018	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(NumberOfClients) (&NumberOfClients), rc);
2019	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BeginTime) (&BeginTime), rc);
2020	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EndTime) (&EndTime), rc);
2021	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSent) (&BytesSent), rc);
2022	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesSentTotal) (&BytesSentTotal), rc);
2023	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceived) (&BytesReceived), rc);
2024	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(BytesReceivedTotal) (&BytesReceivedTotal), rc);
2025	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(User) (User.asOutParam ()), rc);
2026	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(Domain) (Domain.asOutParam ()), rc);
2027	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientName) (ClientName.asOutParam ()), rc);
2028	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientIP) (ClientIP.asOutParam ()), rc);
2029	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(ClientVersion) (&ClientVersion), rc);
2030	CHECK_ERROR_RET(remoteDisplayInfo, COMGETTER(EncryptionStyle) (&EncryptionStyle), rc);
2031
2032	if (details == VMINFO_MACHINEREADABLE)
2033	RTPrintf("VRDPActiveConnection=\"%s\"\n", Active ? "on": "off");
2034	else
2035	RTPrintf("VRDP Connection: %s\n", Active? "active": "not active");
2036
2037	if (details == VMINFO_MACHINEREADABLE)
2038	RTPrintf("VRDPClients=%d\n", NumberOfClients);
2039	else
2040	RTPrintf("Clients so far: %d\n", NumberOfClients);
2041
2042	if (NumberOfClients > 0)
2043	{
2044	char timestr[128];
2045
2046	if (Active)
2047	{
2048	makeTimeStr (timestr, sizeof (timestr), BeginTime);
2049	if (details == VMINFO_MACHINEREADABLE)
2050	RTPrintf("VRDPStartTime=\"%s\"\n", timestr);
2051	else
2052	RTPrintf("Start time: %s\n", timestr);
2053	}
2054	else
2055	{
2056	makeTimeStr (timestr, sizeof (timestr), BeginTime);
2057	if (details == VMINFO_MACHINEREADABLE)
2058	RTPrintf("VRDPLastStartTime=\"%s\"\n", timestr);
2059	else
2060	RTPrintf("Last started: %s\n", timestr);
2061	makeTimeStr (timestr, sizeof (timestr), EndTime);
2062	if (details == VMINFO_MACHINEREADABLE)
2063	RTPrintf("VRDPLastEndTime=\"%s\"\n", timestr);
2064	else
2065	RTPrintf("Last ended: %s\n", timestr);
2066	}
2067
2068	if (details == VMINFO_MACHINEREADABLE)
2069	{
2070	RTPrintf("VRDPBytesSent=%llu\n", BytesSent);
2071	RTPrintf("VRDPThroughputSend=%llu\n", (BytesSent * 1000) / (EndTime - BeginTime) );
2072	RTPrintf("VRDPBytesSentTotal=%llu\n", BytesSentTotal);
2073
2074	RTPrintf("VRDPBytesReceived=%llu\n", BytesReceived);
2075	RTPrintf("VRDPThroughputReceive=%llu\n", (BytesReceived * 1000) / (EndTime - BeginTime) );
2076	RTPrintf("VRDPBytesReceivedTotal=%llu\n", BytesReceivedTotal);
2077	}
2078	else
2079	{
2080	RTPrintf("Sent: %llu Bytes\n", BytesSent);
2081	RTPrintf("Average speed: %llu B/s\n", (BytesSent * 1000) / (EndTime - BeginTime) );
2082	RTPrintf("Sent total: %llu Bytes\n", BytesSentTotal);
2083
2084	RTPrintf("Received: %llu Bytes\n", BytesReceived);
2085	RTPrintf("Speed: %llu B/s\n", (BytesReceived * 1000) / (EndTime - BeginTime) );
2086	RTPrintf("Received total: %llu Bytes\n", BytesReceivedTotal);
2087	}
2088
2089	if (Active)
2090	{
2091	if (details == VMINFO_MACHINEREADABLE)
2092	{
2093	RTPrintf("VRDPUserName=\"%lS\"\n", User.raw());
2094	RTPrintf("VRDPDomain=\"%lS\"\n", Domain.raw());
2095	RTPrintf("VRDPClientName=\"%lS\"\n", ClientName.raw());
2096	RTPrintf("VRDPClientIP=\"%lS\"\n", ClientIP.raw());
2097	RTPrintf("VRDPClientVersion=%d\n", ClientVersion);
2098	RTPrintf("VRDPEncryption=\"%s\"\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
2099	}
2100	else
2101	{
2102	RTPrintf("User name: %lS\n", User.raw());
2103	RTPrintf("Domain: %lS\n", Domain.raw());
2104	RTPrintf("Client name: %lS\n", ClientName.raw());
2105	RTPrintf("Client IP: %lS\n", ClientIP.raw());
2106	RTPrintf("Client version: %d\n", ClientVersion);
2107	RTPrintf("Encryption: %s\n", EncryptionStyle == 0? "RDP4": "RDP5 (X.509)");
2108	}
2109	}
2110	}
2111
2112	if (details != VMINFO_MACHINEREADABLE)
2113	RTPrintf("\n");
2114	}
2115
2116	if ( details == VMINFO_STANDARD
2117	\|\| details == VMINFO_FULL
2118	\|\| details == VMINFO_MACHINEREADABLE)
2119	{
2120	Bstr description;
2121	machine->COMGETTER(Description)(description.asOutParam());
2122	if (!description.isEmpty())
2123	{
2124	if (details == VMINFO_MACHINEREADABLE)
2125	RTPrintf("description=\"%lS\"\n", description.raw());
2126	else
2127	RTPrintf("Description:\n%lS\n", description.raw());
2128	}
2129	}
2130
2131	ULONG guestVal;
2132	if (details != VMINFO_MACHINEREADABLE)
2133	RTPrintf("Guest:\n\n");
2134
2135	rc = machine->COMGETTER(MemoryBalloonSize)(&guestVal);
2136	if (SUCCEEDED(rc))
2137	{
2138	if (details == VMINFO_MACHINEREADABLE)
2139	RTPrintf("GuestMemoryBalloon=%d\n", guestVal);
2140	else
2141	RTPrintf("Configured memory balloon size: %d MB\n", guestVal);
2142	}
2143
2144	rc = machine->COMGETTER(StatisticsUpdateInterval)(&guestVal);
2145	if (SUCCEEDED(rc))
2146	{
2147	if (details == VMINFO_MACHINEREADABLE)
2148	RTPrintf("GuestStatisticsUpdateInterval=%d\n", guestVal);
2149	else
2150	{
2151	if (guestVal == 0)
2152	RTPrintf("Statistics update: disabled\n");
2153	else
2154	RTPrintf("Statistics update interval: %d seconds\n", guestVal);
2155	}
2156	}
2157	if (details != VMINFO_MACHINEREADABLE)
2158	RTPrintf("\n");
2159
2160	if ( console
2161	&& ( details == VMINFO_STATISTICS
2162	\|\| details == VMINFO_FULL
2163	\|\| details == VMINFO_MACHINEREADABLE))
2164	{
2165	ComPtr <IGuest> guest;
2166
2167	rc = console->COMGETTER(Guest)(guest.asOutParam());
2168	if (SUCCEEDED(rc))
2169	{
2170	ULONG statVal;
2171
2172	rc = guest->GetStatistic(0, GuestStatisticType_SampleNumber, &statVal);
2173	if (details == VMINFO_MACHINEREADABLE)
2174	RTPrintf("StatGuestSample=%d\n", statVal);
2175	else
2176	RTPrintf("Guest statistics for sample %d:\n\n", statVal);
2177
2178	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Idle, &statVal);
2179	if (SUCCEEDED(rc))
2180	{
2181	if (details == VMINFO_MACHINEREADABLE)
2182	RTPrintf("StatGuestLoadIdleCPU%d=%d\n", 0, statVal);
2183	else
2184	RTPrintf("CPU%d: CPU Load Idle %-3d%%\n", 0, statVal);
2185	}
2186
2187	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_Kernel, &statVal);
2188	if (SUCCEEDED(rc))
2189	{
2190	if (details == VMINFO_MACHINEREADABLE)
2191	RTPrintf("StatGuestLoadKernelCPU%d=%d\n", 0, statVal);
2192	else
2193	RTPrintf("CPU%d: CPU Load Kernel %-3d%%\n", 0, statVal);
2194	}
2195
2196	rc = guest->GetStatistic(0, GuestStatisticType_CPULoad_User, &statVal);
2197	if (SUCCEEDED(rc))
2198	{
2199	if (details == VMINFO_MACHINEREADABLE)
2200	RTPrintf("StatGuestLoadUserCPU%d=%d\n", 0, statVal);
2201	else
2202	RTPrintf("CPU%d: CPU Load User %-3d%%\n", 0, statVal);
2203	}
2204
2205	rc = guest->GetStatistic(0, GuestStatisticType_Threads, &statVal);
2206	if (SUCCEEDED(rc))
2207	{
2208	if (details == VMINFO_MACHINEREADABLE)
2209	RTPrintf("StatGuestThreadsCPU%d=%d\n", 0, statVal);
2210	else
2211	RTPrintf("CPU%d: Threads %d\n", 0, statVal);
2212	}
2213
2214	rc = guest->GetStatistic(0, GuestStatisticType_Processes, &statVal);
2215	if (SUCCEEDED(rc))
2216	{
2217	if (details == VMINFO_MACHINEREADABLE)
2218	RTPrintf("StatGuestProcessesCPU%d=%d\n", 0, statVal);
2219	else
2220	RTPrintf("CPU%d: Processes %d\n", 0, statVal);
2221	}
2222
2223	rc = guest->GetStatistic(0, GuestStatisticType_Handles, &statVal);
2224	if (SUCCEEDED(rc))
2225	{
2226	if (details == VMINFO_MACHINEREADABLE)
2227	RTPrintf("StatGuestHandlesCPU%d=%d\n", 0, statVal);
2228	else
2229	RTPrintf("CPU%d: Handles %d\n", 0, statVal);
2230	}
2231
2232	rc = guest->GetStatistic(0, GuestStatisticType_MemoryLoad, &statVal);
2233	if (SUCCEEDED(rc))
2234	{
2235	if (details == VMINFO_MACHINEREADABLE)
2236	RTPrintf("StatGuestMemoryLoadCPU%d=%d\n", 0, statVal);
2237	else
2238	RTPrintf("CPU%d: Memory Load %d%%\n", 0, statVal);
2239	}
2240
2241	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemTotal, &statVal);
2242	if (SUCCEEDED(rc))
2243	{
2244	if (details == VMINFO_MACHINEREADABLE)
2245	RTPrintf("StatGuestMemoryTotalPhysCPU%d=%d\n", 0, statVal);
2246	else
2247	RTPrintf("CPU%d: Total physical memory %-4d MB\n", 0, statVal);
2248	}
2249
2250	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemAvailable, &statVal);
2251	if (SUCCEEDED(rc))
2252	{
2253	if (details == VMINFO_MACHINEREADABLE)
2254	RTPrintf("StatGuestMemoryFreePhysCPU%d=%d\n", 0, statVal);
2255	else
2256	RTPrintf("CPU%d: Free physical memory %-4d MB\n", 0, statVal);
2257	}
2258
2259	rc = guest->GetStatistic(0, GuestStatisticType_PhysMemBalloon, &statVal);
2260	if (SUCCEEDED(rc))
2261	{
2262	if (details == VMINFO_MACHINEREADABLE)
2263	RTPrintf("StatGuestMemoryBalloonCPU%d=%d\n", 0, statVal);
2264	else
2265	RTPrintf("CPU%d: Memory balloon size %-4d MB\n", 0, statVal);
2266	}
2267
2268	rc = guest->GetStatistic(0, GuestStatisticType_MemCommitTotal, &statVal);
2269	if (SUCCEEDED(rc))
2270	{
2271	if (details == VMINFO_MACHINEREADABLE)
2272	RTPrintf("StatGuestMemoryCommittedCPU%d=%d\n", 0, statVal);
2273	else
2274	RTPrintf("CPU%d: Committed memory %-4d MB\n", 0, statVal);
2275	}
2276
2277	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelTotal, &statVal);
2278	if (SUCCEEDED(rc))
2279	{
2280	if (details == VMINFO_MACHINEREADABLE)
2281	RTPrintf("StatGuestMemoryTotalKernelCPU%d=%d\n", 0, statVal);
2282	else
2283	RTPrintf("CPU%d: Total kernel memory %-4d MB\n", 0, statVal);
2284	}
2285
2286	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelPaged, &statVal);
2287	if (SUCCEEDED(rc))
2288	{
2289	if (details == VMINFO_MACHINEREADABLE)
2290	RTPrintf("StatGuestMemoryPagedKernelCPU%d=%d\n", 0, statVal);
2291	else
2292	RTPrintf("CPU%d: Paged kernel memory %-4d MB\n", 0, statVal);
2293	}
2294
2295	rc = guest->GetStatistic(0, GuestStatisticType_MemKernelNonpaged, &statVal);
2296	if (SUCCEEDED(rc))
2297	{
2298	if (details == VMINFO_MACHINEREADABLE)
2299	RTPrintf("StatGuestMemoryNonpagedKernelCPU%d=%d\n", 0, statVal);
2300	else
2301	RTPrintf("CPU%d: Nonpaged kernel memory %-4d MB\n", 0, statVal);
2302	}
2303
2304	rc = guest->GetStatistic(0, GuestStatisticType_MemSystemCache, &statVal);
2305	if (SUCCEEDED(rc))
2306	{
2307	if (details == VMINFO_MACHINEREADABLE)
2308	RTPrintf("StatGuestSystemCacheSizeCPU%d=%d\n", 0, statVal);
2309	else
2310	RTPrintf("CPU%d: System cache size %-4d MB\n", 0, statVal);
2311	}
2312
2313	rc = guest->GetStatistic(0, GuestStatisticType_PageFileSize, &statVal);
2314	if (SUCCEEDED(rc))
2315	{
2316	if (details == VMINFO_MACHINEREADABLE)
2317	RTPrintf("StatGuestPageFileSizeCPU%d=%d\n", 0, statVal);
2318	else
2319	RTPrintf("CPU%d: Page file size %-4d MB\n", 0, statVal);
2320	}
2321
2322	RTPrintf("\n");
2323	}
2324	else
2325	{
2326	if (details != VMINFO_MACHINEREADABLE)
2327	{
2328	RTPrintf("[!] FAILED calling console->getGuest at line %d!\n", __LINE__);
2329	PRINT_RC_MESSAGE(rc);
2330	}
2331	}
2332	}
2333
2334	/*
2335	* snapshots
2336	*/
2337	ComPtr<ISnapshot> snapshot;
2338	rc = machine->GetSnapshot(Guid(), snapshot.asOutParam());
2339	if (SUCCEEDED(rc) && snapshot)
2340	{
2341	if (details != VMINFO_MACHINEREADABLE)
2342	RTPrintf("Snapshots:\n\n");
2343	showSnapshots(snapshot, details);
2344	}
2345
2346	if (details != VMINFO_MACHINEREADABLE)
2347	RTPrintf("\n");
2348	return S_OK;
2349	}
2350
2351	static int handleShowVMInfo(int argc, char *argv[],
2352	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
2353	{
2354	HRESULT rc;
2355
2356	/* at least one option: the UUID or name of the VM */
2357	if (argc < 1)
2358	{
2359	return errorSyntax(USAGE_SHOWVMINFO, "Incorrect number of parameters");
2360	}
2361
2362	/* try to find the given machine */
2363	ComPtr <IMachine> machine;
2364	Guid uuid (argv[0]);
2365	if (!uuid.isEmpty())
2366	{
2367	CHECK_ERROR (virtualBox, GetMachine (uuid, machine.asOutParam()));
2368	}
2369	else
2370	{
2371	CHECK_ERROR (virtualBox, FindMachine (Bstr(argv[0]), machine.asOutParam()));
2372	if (SUCCEEDED (rc))
2373	machine->COMGETTER(Id) (uuid.asOutParam());
2374	}
2375	if (FAILED (rc))
2376	return 1;
2377
2378	/* 2nd option can be -details, -statistics or -argdump */
2379	VMINFO_DETAILS details = VMINFO_NONE;
2380	bool fDetails = false;
2381	bool fStatistics = false;
2382	bool fMachinereadable = false;
2383	for (int i=1;i<argc;i++)
2384	{
2385	if (!strcmp(argv[i], "-details"))
2386	fDetails = true;
2387	else
2388	if (!strcmp(argv[i], "-statistics"))
2389	fStatistics = true;
2390	if (!strcmp(argv[1], "-machinereadable"))
2391	fMachinereadable = true;
2392	}
2393	if (fMachinereadable)
2394	details = VMINFO_MACHINEREADABLE;
2395	else
2396	if (fDetails && fStatistics)
2397	details = VMINFO_FULL;
2398	else
2399	if (fDetails)
2400	details = VMINFO_STANDARD;
2401	else
2402	if (fStatistics)
2403	details = VMINFO_STATISTICS;
2404
2405	ComPtr <IConsole> console;
2406
2407	/* open an existing session for the VM */
2408	rc = virtualBox->OpenExistingSession (session, uuid);
2409	if (SUCCEEDED(rc))
2410	/* get the session machine */
2411	rc = session->COMGETTER(Machine)(machine.asOutParam());
2412	if (SUCCEEDED(rc))
2413	/* get the session console */
2414	rc = session->COMGETTER(Console)(console.asOutParam());
2415
2416	rc = showVMInfo (virtualBox, machine, console, details);
2417
2418	if (console)
2419	session->Close();
2420
2421	return SUCCEEDED (rc) ? 0 : 1;
2422	}
2423
2424
2425	static int handleList(int argc, char *argv[],
2426	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
2427	{
2428	HRESULT rc = S_OK;
2429
2430	/* exactly one option: the object */
2431	if (argc != 1)
2432	{
2433	return errorSyntax(USAGE_LIST, "Incorrect number of parameters");
2434	}
2435
2436	/* which object? */
2437	if (strcmp(argv[0], "vms") == 0)
2438	{
2439	/*
2440	* Get the list of all registered VMs
2441	*/
2442	ComPtr<IMachineCollection> collection;
2443	rc = virtualBox->COMGETTER(Machines)(collection.asOutParam());
2444	ComPtr<IMachineEnumerator> enumerator;
2445	if (SUCCEEDED(rc))
2446	rc = collection->Enumerate(enumerator.asOutParam());
2447	if (SUCCEEDED(rc))
2448	{
2449	/*
2450	* Iterate through the collection
2451	*/
2452	BOOL hasMore = FALSE;
2453	while (enumerator->HasMore(&hasMore), hasMore)
2454	{
2455	ComPtr<IMachine> machine;
2456	rc = enumerator->GetNext(machine.asOutParam());
2457	if ((SUCCEEDED(rc)) && machine)
2458	{
2459	rc = showVMInfo(virtualBox, machine);
2460	}
2461	}
2462	}
2463	}
2464	else
2465	if (strcmp(argv[0], "runningvms") == 0)
2466	{
2467	/*
2468	* Get the list of all _running_ VMs
2469	*/
2470	ComPtr<IMachineCollection> collection;
2471	rc = virtualBox->COMGETTER(Machines)(collection.asOutParam());
2472	ComPtr<IMachineEnumerator> enumerator;
2473	if (SUCCEEDED(rc))
2474	rc = collection->Enumerate(enumerator.asOutParam());
2475	if (SUCCEEDED(rc))
2476	{
2477	/*
2478	* Iterate through the collection
2479	*/
2480	BOOL hasMore = FALSE;
2481	while (enumerator->HasMore(&hasMore), hasMore)
2482	{
2483	ComPtr<IMachine> machine;
2484	rc = enumerator->GetNext(machine.asOutParam());
2485	if ((SUCCEEDED(rc)) && machine)
2486	{
2487	MachineState_T machineState;
2488	rc = machine->COMGETTER(State)(&machineState);
2489	if (SUCCEEDED(rc))
2490	{
2491	switch (machineState)
2492	{
2493	case MachineState_Running:
2494	case MachineState_Paused:
2495	{
2496	Guid uuid;
2497	rc = machine->COMGETTER(Id) (uuid.asOutParam());
2498	if (SUCCEEDED(rc))
2499	RTPrintf ("%s\n", uuid.toString().raw());
2500	break;
2501	}
2502	}
2503	}
2504	}
2505	}
2506	}
2507	}
2508	else
2509	if (strcmp(argv[0], "ostypes") == 0)
2510	{
2511	ComPtr<IGuestOSTypeCollection> coll;
2512	ComPtr<IGuestOSTypeEnumerator> enumerator;
2513	CHECK_ERROR(virtualBox, COMGETTER(GuestOSTypes)(coll.asOutParam()));
2514	if (SUCCEEDED(rc) && coll)
2515	{
2516	CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));
2517	BOOL hasMore;
2518	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2519	{
2520	ComPtr<IGuestOSType> guestOS;
2521	CHECK_RC_BREAK(enumerator->GetNext(guestOS.asOutParam()));
2522	Bstr guestId;
2523	guestOS->COMGETTER(Id)(guestId.asOutParam());
2524	RTPrintf("ID: %lS\n", guestId.raw());
2525	Bstr guestDescription;
2526	guestOS->COMGETTER(Description)(guestDescription.asOutParam());
2527	RTPrintf("Description: %lS\n\n", guestDescription.raw());
2528	}
2529	}
2530	}
2531	else
2532	if (strcmp(argv[0], "hostdvds") == 0)
2533	{
2534	ComPtr<IHost> host;
2535	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
2536	ComPtr<IHostDVDDriveCollection> coll;
2537	ComPtr<IHostDVDDriveEnumerator> enumerator;
2538	CHECK_ERROR(host, COMGETTER(DVDDrives)(coll.asOutParam()));
2539	if (SUCCEEDED(rc) && coll)
2540	{
2541	CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));
2542	BOOL hasMore;
2543	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2544	{
2545	ComPtr<IHostDVDDrive> dvdDrive;
2546	CHECK_RC_BREAK(enumerator->GetNext(dvdDrive.asOutParam()));
2547	Bstr name;
2548	dvdDrive->COMGETTER(Name)(name.asOutParam());
2549	RTPrintf("Name: %lS\n\n", name.raw());
2550	}
2551	}
2552	}
2553	else
2554	if (strcmp(argv[0], "hostfloppies") == 0)
2555	{
2556	ComPtr<IHost> host;
2557	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
2558	ComPtr<IHostFloppyDriveCollection> coll;
2559	ComPtr<IHostFloppyDriveEnumerator> enumerator;
2560	CHECK_ERROR(host, COMGETTER(FloppyDrives)(coll.asOutParam()));
2561	if (SUCCEEDED(rc) && coll)
2562	{
2563	CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));
2564	BOOL hasMore;
2565	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2566	{
2567	ComPtr<IHostFloppyDrive> floppyDrive;
2568	CHECK_RC_BREAK(enumerator->GetNext(floppyDrive.asOutParam()));
2569	Bstr name;
2570	floppyDrive->COMGETTER(Name)(name.asOutParam());
2571	RTPrintf("Name: %lS\n\n", name.raw());
2572	}
2573	}
2574	}
2575	#ifdef RT_OS_WINDOWS
2576	else
2577	if (strcmp(argv[0], "hostifs") == 0)
2578	{
2579	ComPtr<IHost> host;
2580	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
2581	ComPtr<IHostNetworkInterfaceCollection> coll;
2582	ComPtr<IHostNetworkInterfaceEnumerator> enumerator;
2583	CHECK_ERROR(host, COMGETTER(NetworkInterfaces)(coll.asOutParam()));
2584	if (SUCCEEDED(rc) && coll)
2585	{
2586	CHECK_ERROR(coll, Enumerate(enumerator.asOutParam()));
2587	BOOL hasMore;
2588	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2589	{
2590	ComPtr<IHostNetworkInterface> networkInterface;
2591	CHECK_RC_BREAK(enumerator->GetNext(networkInterface.asOutParam()));
2592	Bstr interfaceName;
2593	networkInterface->COMGETTER(Name)(interfaceName.asOutParam());
2594	RTPrintf("Name: %lS\n", interfaceName.raw());
2595	Guid interfaceGuid;
2596	networkInterface->COMGETTER(Id)(interfaceGuid.asOutParam());
2597	RTPrintf("GUID: %lS\n\n", Bstr(interfaceGuid.toString()));
2598	}
2599	}
2600	}
2601	#endif /* RT_OS_WINDOWS */
2602	else
2603	if (strcmp(argv[0], "hdds") == 0)
2604	{
2605	ComPtr<IHardDiskCollection> hddColl;
2606	CHECK_ERROR(virtualBox, COMGETTER(HardDisks)(hddColl.asOutParam()));
2607	ComPtr<IHardDiskEnumerator> enumerator;
2608	CHECK_ERROR(hddColl, Enumerate(enumerator.asOutParam()));
2609	BOOL hasMore;
2610	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2611	{
2612	ComPtr<IHardDisk> hdd;
2613	CHECK_RC_BREAK(enumerator->GetNext(hdd.asOutParam()));
2614	Guid uuid;
2615	hdd->COMGETTER(Id)(uuid.asOutParam());
2616	RTPrintf("UUID: %s\n", uuid.toString().raw());
2617	HardDiskStorageType_T storageType;
2618	hdd->COMGETTER(StorageType)(&storageType);
2619	const char *storageTypeString = "unknown";
2620	switch (storageType)
2621	{
2622	case HardDiskStorageType_VirtualDiskImage:
2623	storageTypeString = "Virtual Disk Image";
2624	break;
2625	case HardDiskStorageType_ISCSIHardDisk:
2626	storageTypeString = "iSCSI hard disk";
2627	break;
2628	}
2629	RTPrintf("Storage type: %s\n", storageTypeString);
2630	Bstr filepath;
2631	/// @todo (dmik) we temporarily use the location property to
2632	// determine the image file name. This is subject to change
2633	// when iSCSI disks are here (we should either query a
2634	// storage-specific interface from IHardDisk, or "standardize"
2635	// the location property)
2636	hdd->COMGETTER(Location)(filepath.asOutParam());
2637	RTPrintf("Path: %lS\n", filepath.raw());
2638	BOOL fAccessible;
2639	hdd->COMGETTER(AllAccessible)(&fAccessible);
2640	RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");
2641	Guid machineUUID;
2642	hdd->COMGETTER(MachineId)(machineUUID.asOutParam());
2643	if (!machineUUID.isEmpty())
2644	{
2645	ComPtr<IMachine> machine;
2646	CHECK_ERROR(virtualBox, GetMachine(machineUUID, machine.asOutParam()));
2647	ASSERT(machine);
2648	Bstr name;
2649	machine->COMGETTER(Name)(name.asOutParam());
2650	machine->COMGETTER(Id)(uuid.asOutParam());
2651	RTPrintf("Usage: %lS (UUID: %s)\n", name.raw(), uuid.toString().raw());
2652	}
2653	RTPrintf("\n");
2654	}
2655	}
2656	else
2657	if (strcmp(argv[0], "dvds") == 0)
2658	{
2659	ComPtr<IDVDImageCollection> dvdColl;
2660	CHECK_ERROR(virtualBox, COMGETTER(DVDImages)(dvdColl.asOutParam()));
2661	ComPtr<IDVDImageEnumerator> enumerator;
2662	CHECK_ERROR(dvdColl, Enumerate(enumerator.asOutParam()));
2663	BOOL hasMore;
2664	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2665	{
2666	ComPtr<IDVDImage> dvdImage;
2667	CHECK_RC_BREAK(enumerator->GetNext(dvdImage.asOutParam()));
2668	Guid uuid;
2669	dvdImage->COMGETTER(Id)(uuid.asOutParam());
2670	RTPrintf("UUID: %s\n", uuid.toString().raw());
2671	Bstr filePath;
2672	dvdImage->COMGETTER(FilePath)(filePath.asOutParam());
2673	RTPrintf("Path: %lS\n", filePath.raw());
2674	BOOL fAccessible;
2675	dvdImage->COMGETTER(Accessible)(&fAccessible);
2676	RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");
2677	Bstr machineUUIDs;
2678	CHECK_ERROR(virtualBox, GetDVDImageUsage(uuid, ResourceUsage_AllUsage, machineUUIDs.asOutParam()));
2679	/** @todo usage */
2680	RTPrintf("\n");
2681	}
2682	}
2683	else
2684	if (strcmp(argv[0], "floppies") == 0)
2685	{
2686	ComPtr<IFloppyImageCollection> floppyColl;
2687	CHECK_ERROR(virtualBox, COMGETTER(FloppyImages)(floppyColl.asOutParam()));
2688	ComPtr<IFloppyImageEnumerator> enumerator;
2689	CHECK_ERROR(floppyColl, Enumerate(enumerator.asOutParam()));
2690	BOOL hasMore;
2691	while (SUCCEEDED(enumerator->HasMore(&hasMore)) && hasMore)
2692	{
2693	ComPtr<IFloppyImage> floppyImage;
2694	CHECK_RC_BREAK(enumerator->GetNext(floppyImage.asOutParam()));
2695	Guid uuid;
2696	floppyImage->COMGETTER(Id)(uuid.asOutParam());
2697	RTPrintf("UUID: %s\n", uuid.toString().raw());
2698	Bstr filePath;
2699	floppyImage->COMGETTER(FilePath)(filePath.asOutParam());
2700	RTPrintf("Path: %lS\n", filePath.raw());
2701	BOOL fAccessible;
2702	floppyImage->COMGETTER(Accessible)(&fAccessible);
2703	RTPrintf("Accessible: %s\n", fAccessible ? "yes" : "no");
2704	Bstr machineUUIDs;
2705	CHECK_ERROR(virtualBox, GetFloppyImageUsage(uuid, ResourceUsage_AllUsage, machineUUIDs.asOutParam()));
2706	/** @todo usage */
2707	RTPrintf("\n");
2708	}
2709	}
2710	else
2711	if (strcmp(argv[0], "usbhost") == 0)
2712	{
2713	ComPtr<IHost> Host;
2714	CHECK_ERROR_RET (virtualBox, COMGETTER(Host)(Host.asOutParam()), 1);
2715
2716	ComPtr<IHostUSBDeviceCollection> CollPtr;
2717	CHECK_ERROR_RET (Host, COMGETTER(USBDevices)(CollPtr.asOutParam()), 1);
2718
2719	ComPtr<IHostUSBDeviceEnumerator> EnumPtr;
2720	CHECK_ERROR_RET (CollPtr, Enumerate(EnumPtr.asOutParam()), 1);
2721
2722	RTPrintf("Host USB Devices:\n\n");
2723
2724	BOOL fMore = FALSE;
2725	rc = EnumPtr->HasMore (&fMore);
2726	ASSERT_RET (SUCCEEDED (rc), 1);
2727
2728	if (!fMore)
2729	{
2730	RTPrintf("<none>\n\n");
2731	}
2732	else
2733	while (fMore)
2734	{
2735	ComPtr <IHostUSBDevice> dev;
2736	rc = EnumPtr->GetNext (dev.asOutParam());
2737	ASSERT_RET (SUCCEEDED (rc), 1);
2738
2739	/* Query info. */
2740	Guid id;
2741	CHECK_ERROR_RET (dev, COMGETTER(Id)(id.asOutParam()), 1);
2742	USHORT usVendorId;
2743	CHECK_ERROR_RET (dev, COMGETTER(VendorId)(&usVendorId), 1);
2744	USHORT usProductId;
2745	CHECK_ERROR_RET (dev, COMGETTER(ProductId)(&usProductId), 1);
2746	USHORT bcdRevision;
2747	CHECK_ERROR_RET (dev, COMGETTER(Revision)(&bcdRevision), 1);
2748
2749	RTPrintf("UUID: %S\n"
2750	"VendorId: 0x%04x (%04X)\n"
2751	"ProductId: 0x%04x (%04X)\n"
2752	"Revision: %u.%u (%02u%02u)\n",
2753	id.toString().raw(),
2754	usVendorId, usVendorId, usProductId, usProductId,
2755	bcdRevision >> 8, bcdRevision & 0xff,
2756	bcdRevision >> 8, bcdRevision & 0xff);
2757
2758	/* optional stuff. */
2759	Bstr bstr;
2760	CHECK_ERROR_RET (dev, COMGETTER(Manufacturer)(bstr.asOutParam()), 1);
2761	if (!bstr.isEmpty())
2762	RTPrintf("Manufacturer: %lS\n", bstr.raw());
2763	CHECK_ERROR_RET (dev, COMGETTER(Product)(bstr.asOutParam()), 1);
2764	if (!bstr.isEmpty())
2765	RTPrintf("Product: %lS\n", bstr.raw());
2766	CHECK_ERROR_RET (dev, COMGETTER(SerialNumber)(bstr.asOutParam()), 1);
2767	if (!bstr.isEmpty())
2768	RTPrintf("SerialNumber: %lS\n", bstr.raw());
2769	CHECK_ERROR_RET (dev, COMGETTER(Address)(bstr.asOutParam()), 1);
2770	if (!bstr.isEmpty())
2771	RTPrintf("Address: %lS\n", bstr.raw());
2772
2773	/* current state */
2774	USBDeviceState_T state;
2775	CHECK_ERROR_RET (dev, COMGETTER(State)(&state), 1);
2776	const char *pszState = "?";
2777	switch (state)
2778	{
2779	case USBDeviceState_USBDeviceNotSupported:
2780	pszState = "Not supported"; break;
2781	case USBDeviceState_USBDeviceUnavailable:
2782	pszState = "Unavailable"; break;
2783	case USBDeviceState_USBDeviceBusy:
2784	pszState = "Busy"; break;
2785	case USBDeviceState_USBDeviceAvailable:
2786	pszState = "Available"; break;
2787	case USBDeviceState_USBDeviceHeld:
2788	pszState = "Held"; break;
2789	case USBDeviceState_USBDeviceCaptured:
2790	pszState = "Captured"; break;
2791	default:
2792	ASSERT (false);
2793	break;
2794	}
2795	RTPrintf("Current State: %s\n\n", pszState);
2796
2797	rc = EnumPtr->HasMore (&fMore);
2798	ASSERT_RET (SUCCEEDED (rc), rc);
2799	}
2800	}
2801	else
2802	if (strcmp(argv[0], "usbfilters") == 0)
2803	{
2804	RTPrintf("Global USB Device Filters:\n\n");
2805
2806	ComPtr <IHost> host;
2807	CHECK_ERROR_RET (virtualBox, COMGETTER(Host) (host.asOutParam()), 1);
2808
2809	ComPtr<IHostUSBDeviceFilterCollection> coll;
2810	CHECK_ERROR_RET (host, COMGETTER (USBDeviceFilters)(coll.asOutParam()), 1);
2811
2812	ComPtr<IHostUSBDeviceFilterEnumerator> en;
2813	CHECK_ERROR_RET (coll, Enumerate(en.asOutParam()), 1);
2814
2815	ULONG index = 0;
2816	BOOL more = FALSE;
2817	rc = en->HasMore (&more);
2818	ASSERT_RET (SUCCEEDED (rc), 1);
2819
2820	if (!more)
2821	{
2822	RTPrintf("<none>\n\n");
2823	}
2824	else
2825	while (more)
2826	{
2827	ComPtr<IHostUSBDeviceFilter> flt;
2828	rc = en->GetNext (flt.asOutParam());
2829	ASSERT_RET (SUCCEEDED (rc), 1);
2830
2831	/* Query info. */
2832
2833	RTPrintf("Index: %lu\n", index);
2834
2835	BOOL active = FALSE;
2836	CHECK_ERROR_RET (flt, COMGETTER (Active) (&active), 1);
2837	RTPrintf("Active: %s\n", active ? "yes" : "no");
2838
2839	USBDeviceFilterAction_T action;
2840	CHECK_ERROR_RET (flt, COMGETTER (Action) (&action), 1);
2841	const char *pszAction = "<invalid>";
2842	switch (action)
2843	{
2844	case USBDeviceFilterAction_USBDeviceFilterIgnore:
2845	pszAction = "Ignore";
2846	break;
2847	case USBDeviceFilterAction_USBDeviceFilterHold:
2848	pszAction = "Hold";
2849	break;
2850	default:
2851	break;
2852	}
2853	RTPrintf("Action: %s\n", pszAction);
2854
2855	Bstr bstr;
2856	CHECK_ERROR_RET (flt, COMGETTER (Name) (bstr.asOutParam()), 1);
2857	RTPrintf("Name: %lS\n", bstr.raw());
2858	CHECK_ERROR_RET (flt, COMGETTER (VendorId) (bstr.asOutParam()), 1);
2859	RTPrintf("VendorId: %lS\n", bstr.raw());
2860	CHECK_ERROR_RET (flt, COMGETTER (ProductId) (bstr.asOutParam()), 1);
2861	RTPrintf("ProductId: %lS\n", bstr.raw());
2862	CHECK_ERROR_RET (flt, COMGETTER (Revision) (bstr.asOutParam()), 1);
2863	RTPrintf("Revision: %lS\n", bstr.raw());
2864	CHECK_ERROR_RET (flt, COMGETTER (Manufacturer) (bstr.asOutParam()), 1);
2865	RTPrintf("Manufacturer: %lS\n", bstr.raw());
2866	CHECK_ERROR_RET (flt, COMGETTER (Product) (bstr.asOutParam()), 1);
2867	RTPrintf("Product: %lS\n", bstr.raw());
2868	CHECK_ERROR_RET (flt, COMGETTER (SerialNumber) (bstr.asOutParam()), 1);
2869	RTPrintf("Serial Number: %lS\n\n", bstr.raw());
2870
2871	rc = en->HasMore (&more);
2872	ASSERT_RET (SUCCEEDED (rc), 1);
2873
2874	index ++;
2875	}
2876	}
2877	else if (strcmp(argv[0], "systemproperties") == 0)
2878	{
2879	ComPtr<ISystemProperties> systemProperties;
2880	virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
2881
2882	Bstr str;
2883	ULONG ulValue;
2884	ULONG64 ul64Value;
2885	BOOL flag;
2886
2887	systemProperties->COMGETTER(MinGuestRAM)(&ulValue);
2888	RTPrintf("Minimum guest RAM size: %u Megabytes\n", ulValue);
2889	systemProperties->COMGETTER(MaxGuestRAM)(&ulValue);
2890	RTPrintf("Maximum guest RAM size: %u Megabytes\n", ulValue);
2891	systemProperties->COMGETTER(MaxGuestVRAM)(&ulValue);
2892	RTPrintf("Maximum video RAM size: %u Megabytes\n", ulValue);
2893	systemProperties->COMGETTER(MaxVDISize)(&ul64Value);
2894	RTPrintf("Maximum VDI size: %lu Megabytes\n", ul64Value);
2895	systemProperties->COMGETTER(DefaultVDIFolder)(str.asOutParam());
2896	RTPrintf("Default VDI filder: %lS\n", str.raw());
2897	systemProperties->COMGETTER(DefaultMachineFolder)(str.asOutParam());
2898	RTPrintf("Default machine folder: %lS\n", str.raw());
2899	systemProperties->COMGETTER(RemoteDisplayAuthLibrary)(str.asOutParam());
2900	RTPrintf("VRDP authentication library: %lS\n", str.raw());
2901	systemProperties->COMGETTER(WebServiceAuthLibrary)(str.asOutParam());
2902	RTPrintf("Webservice auth. library: %lS\n", str.raw());
2903	systemProperties->COMGETTER(HWVirtExEnabled)(&flag);
2904	RTPrintf("Hardware virt. extensions: %s\n", flag ? "yes" : "no");
2905	systemProperties->COMGETTER(LogHistoryCount)(&ulValue);
2906	RTPrintf("Log history count: %u\n", ulValue);
2907
2908	}
2909	else
2910	{
2911	return errorSyntax(USAGE_LIST, "Invalid parameter '%s'", Utf8Str(argv[0]).raw());
2912	}
2913	return SUCCEEDED(rc) ? 0 : 1;
2914	}
2915
2916	static int handleRegisterVM(int argc, char *argv[],
2917	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
2918	{
2919	HRESULT rc;
2920
2921	if (argc != 1)
2922	{
2923	return errorSyntax(USAGE_REGISTERVM, "Incorrect number of parameters");
2924	}
2925
2926	ComPtr<IMachine> machine;
2927	CHECK_ERROR(virtualBox, OpenMachine(Bstr(argv[0]), machine.asOutParam()));
2928	if (SUCCEEDED(rc))
2929	{
2930	ASSERT(machine);
2931	CHECK_ERROR(virtualBox, RegisterMachine(machine));
2932	}
2933	return SUCCEEDED(rc) ? 0 : 1;
2934	}
2935
2936	static int handleUnregisterVM(int argc, char *argv[],
2937	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
2938	{
2939	HRESULT rc;
2940
2941	if ((argc != 1) && (argc != 2))
2942	{
2943	return errorSyntax(USAGE_UNREGISTERVM, "Incorrect number of parameters");
2944	}
2945
2946	ComPtr<IMachine> machine;
2947	/* assume it's a UUID */
2948	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
2949	if (FAILED(rc) \|\| !machine)
2950	{
2951	/* must be a name */
2952	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
2953	}
2954	if (machine)
2955	{
2956	Guid uuid;
2957	machine->COMGETTER(Id)(uuid.asOutParam());
2958	machine = NULL;
2959	CHECK_ERROR(virtualBox, UnregisterMachine(uuid, machine.asOutParam()));
2960	if (SUCCEEDED(rc) && machine)
2961	{
2962	/* are we supposed to delete the config file? */
2963	if ((argc == 2) && (strcmp(argv[1], "-delete") == 0))
2964	{
2965	CHECK_ERROR(machine, DeleteSettings());
2966	}
2967	}
2968	}
2969	return SUCCEEDED(rc) ? 0 : 1;
2970	}
2971
2972	static int handleCreateVDI(int argc, char *argv[],
2973	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
2974	{
2975	HRESULT rc;
2976	Bstr filename;
2977	uint64_t sizeMB = 0;
2978	bool fStatic = false;
2979	Bstr comment;
2980	bool fRegister = false;
2981	const char *type = "normal";
2982
2983	/* let's have a closer look at the arguments */
2984	for (int i = 0; i < argc; i++)
2985	{
2986	if (strcmp(argv[i], "-filename") == 0)
2987	{
2988	if (argc <= i + 1)
2989	{
2990	return errorArgument("Missing argument to '%s'", argv[i]);
2991	}
2992	i++;
2993	filename = argv[i];
2994	}
2995	else if (strcmp(argv[i], "-size") == 0)
2996	{
2997	if (argc <= i + 1)
2998	{
2999	return errorArgument("Missing argument to '%s'", argv[i]);
3000	}
3001	i++;
3002	sizeMB = RTStrToUInt64(argv[i]);
3003	}
3004	else if (strcmp(argv[i], "-static") == 0)
3005	{
3006	fStatic = true;
3007	}
3008	else if (strcmp(argv[i], "-comment") == 0)
3009	{
3010	if (argc <= i + 1)
3011	{
3012	return errorArgument("Missing argument to '%s'", argv[i]);
3013	}
3014	i++;
3015	comment = argv[i];
3016	}
3017	else if (strcmp(argv[i], "-register") == 0)
3018	{
3019	fRegister = true;
3020	}
3021	else if (strcmp(argv[i], "-type") == 0)
3022	{
3023	if (argc <= i + 1)
3024	{
3025	return errorArgument("Missing argument to '%s'", argv[i]);
3026	}
3027	i++;
3028	type = argv[i];
3029	}
3030	else
3031	{
3032	return errorSyntax(USAGE_CREATEVDI, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
3033	}
3034	}
3035	/* check the outcome */
3036	if (!filename \|\| (sizeMB == 0))
3037	{
3038	return errorSyntax(USAGE_CREATEVDI, "Parameters -filename and -size are required");
3039	}
3040	if (strcmp(type, "normal") && strcmp(type, "writethrough"))
3041	{
3042	return errorArgument("Invalid VDI type '%s' specified", Utf8Str(type).raw());
3043	}
3044
3045	ComPtr<IHardDisk> hardDisk;
3046	CHECK_ERROR(virtualBox, CreateHardDisk(HardDiskStorageType_VirtualDiskImage, hardDisk.asOutParam()));
3047	if (SUCCEEDED(rc) && hardDisk)
3048	{
3049	CHECK_ERROR(hardDisk,COMSETTER(Description)(comment));
3050	ComPtr<IVirtualDiskImage> vdi = hardDisk;
3051	CHECK_ERROR(vdi, COMSETTER(FilePath)(filename));
3052	ComPtr<IProgress> progress;
3053	if (fStatic)
3054	{
3055	CHECK_ERROR(vdi, CreateFixedImage(sizeMB, progress.asOutParam()));
3056	}
3057	else
3058	{
3059	CHECK_ERROR(vdi, CreateDynamicImage(sizeMB, progress.asOutParam()));
3060	}
3061	if (SUCCEEDED(rc) && progress)
3062	{
3063	if (fStatic)
3064	showProgress(progress);
3065	else
3066	CHECK_ERROR(progress, WaitForCompletion(-1));
3067	if (SUCCEEDED(rc))
3068	{
3069	progress->COMGETTER(ResultCode)(&rc);
3070	if (FAILED(rc))
3071	{
3072	com::ProgressErrorInfo info(progress);
3073	if (info.isBasicAvailable())
3074	{
3075	RTPrintf("Error: failed to create disk image. Error message: %lS\n", info.getText().raw());
3076	}
3077	else
3078	{
3079	RTPrintf("Error: failed to create disk image. No error message available!\n");
3080	}
3081	}
3082	else
3083	{
3084	Guid uuid;
3085	CHECK_ERROR(hardDisk, COMGETTER(Id)(uuid.asOutParam()));
3086
3087	if (strcmp(type, "normal") == 0)
3088	{
3089	/* nothing required, default */
3090	}
3091	else if (strcmp(type, "writethrough") == 0)
3092	{
3093	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_WritethroughHardDisk));
3094	}
3095
3096	RTPrintf("Disk image created. UUID: %s\n", uuid.toString().raw());
3097	}
3098	}
3099	}
3100	if (SUCCEEDED(rc) && fRegister)
3101	{
3102	CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));
3103	}
3104	}
3105	return SUCCEEDED(rc) ? 0 : 1;
3106	}
3107
3108	static DECLCALLBACK(int) vdiProgressCallback(PVM pVM, unsigned uPercent, void *pvUser)
3109	{
3110	unsigned pPercent = (unsigned )pvUser;
3111
3112	if (*pPercent != uPercent)
3113	{
3114	*pPercent = uPercent;
3115	RTPrintf(".");
3116	if ((uPercent % 10) == 0 && uPercent)
3117	RTPrintf("%d%%", uPercent);
3118	RTStrmFlush(g_pStdOut);
3119	}
3120
3121	return VINF_SUCCESS;
3122	}
3123
3124
3125	static int handleModifyVDI(int argc, char *argv[],
3126	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
3127	{
3128	HRESULT rc;
3129
3130	/* The uuid/filename and a command */
3131	if (argc < 2)
3132	{
3133	return errorSyntax(USAGE_MODIFYVDI, "Incorrect number of parameters");
3134	}
3135
3136	ComPtr<IHardDisk> hardDisk;
3137	ComPtr<IVirtualDiskImage> vdi;
3138	Bstr filepath;
3139
3140	/* first guess is that it's a UUID */
3141	Guid uuid(argv[0]);
3142	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
3143	/* no? then it must be a filename */
3144	if (!hardDisk)
3145	{
3146	filepath = argv[0];
3147	CHECK_ERROR(virtualBox, FindVirtualDiskImage(filepath, vdi.asOutParam()));
3148	hardDisk = vdi;
3149	}
3150	else
3151	{
3152	vdi = hardDisk;
3153	}
3154
3155	/* let's find out which command */
3156	// doesn't currently work if (strcmp(argv[1], "settype") == 0)
3157	if (0)
3158	{
3159	/* hard disk must be registered */
3160	if (SUCCEEDED(rc) && hardDisk && vdi)
3161	{
3162	char *type = NULL;
3163
3164	if (argc <= 2)
3165	{
3166	return errorArgument("Missing argument to for settype");
3167	}
3168	type = argv[2];
3169
3170	HardDiskType_T hddType;
3171	CHECK_ERROR(hardDisk, COMGETTER(Type)(&hddType));
3172
3173	if (strcmp(type, "normal") == 0)
3174	{
3175	if (hddType != HardDiskType_NormalHardDisk)
3176	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_NormalHardDisk));
3177	}
3178	else if (strcmp(type, "writethrough") == 0)
3179	{
3180	if (hddType != HardDiskType_WritethroughHardDisk)
3181	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_WritethroughHardDisk));
3182
3183	}
3184	else if (strcmp(type, "immutable") == 0)
3185	{
3186	if (hddType != HardDiskType_ImmutableHardDisk)
3187	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_ImmutableHardDisk));
3188	}
3189	else
3190	{
3191	return errorArgument("Invalid VDI type '%s' specified", Utf8Str(type).raw());
3192	}
3193	}
3194	else
3195	{
3196	return errorArgument("Hard disk image not registered");
3197	}
3198	}
3199	else if (strcmp(argv[1], "compact") == 0)
3200	{
3201	ComPtr<IVirtualDiskImage> vdi;
3202
3203	/* the hard disk image might not be registered */
3204	if (!hardDisk)
3205	{
3206	virtualBox->OpenVirtualDiskImage(Bstr(argv[0]), vdi.asOutParam());
3207	if (!vdi)
3208	{
3209	return errorArgument("Hard disk image not found");
3210	}
3211	}
3212	else
3213	vdi = hardDisk;
3214
3215	if (!vdi)
3216	return errorArgument("Invalid hard disk type. The command only works on VDI files\n");
3217
3218	Bstr fileName;
3219	vdi->COMGETTER(FilePath)(fileName.asOutParam());
3220
3221	/* close the file */
3222	hardDisk = NULL;
3223	vdi = NULL;
3224
3225	unsigned uProcent;
3226
3227	RTPrintf("Shrinking '%lS': 0%%", fileName.raw());
3228	int vrc = VDIShrinkImage(Utf8Str(fileName).raw(), vdiProgressCallback, &uProcent);
3229	if (VBOX_FAILURE(vrc))
3230	{
3231	RTPrintf("Error while shrinking hard disk image: %Vrc\n", vrc);
3232	rc = E_FAIL;
3233	}
3234	}
3235	else
3236	{
3237	return errorSyntax(USAGE_MODIFYVDI, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
3238	}
3239	return SUCCEEDED(rc) ? 0 : 1;
3240	}
3241
3242	static int handleCloneVDI(int argc, char *argv[],
3243	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
3244	{
3245	HRESULT rc;
3246
3247	/* source VDI and target path */
3248	if (argc != 2)
3249	{
3250	return errorSyntax(USAGE_CLONEVDI, "Incorrect number of parameters");
3251	}
3252
3253	/* first guess is that it's a UUID */
3254	Guid uuid(argv[0]);
3255	ComPtr<IHardDisk> hardDisk;
3256	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
3257	if (!hardDisk)
3258	{
3259	/* not successful? Then it must be a filename */
3260	ComPtr<IVirtualDiskImage> vdi;
3261	CHECK_ERROR(virtualBox, OpenVirtualDiskImage(Bstr(argv[0]), vdi.asOutParam()));
3262	hardDisk = vdi;
3263	}
3264	if (hardDisk)
3265	{
3266	ComPtr<IVirtualDiskImage> vdiOut;
3267	ComPtr<IProgress> progress;
3268	CHECK_ERROR(hardDisk, CloneToImage(Bstr(argv[1]), vdiOut.asOutParam(), progress.asOutParam()));
3269	if (SUCCEEDED(rc))
3270	{
3271	showProgress(progress);
3272	progress->COMGETTER(ResultCode)(&rc);
3273	if (FAILED(rc))
3274	{
3275	com::ProgressErrorInfo info(progress);
3276	if (info.isBasicAvailable())
3277	{
3278	RTPrintf("Error: failed to clone disk image. Error message: %lS\n", info.getText().raw());
3279	}
3280	else
3281	{
3282	RTPrintf("Error: failed to clone disk image. No error message available!\n");
3283	}
3284	}
3285	}
3286	}
3287	return SUCCEEDED(rc) ? 0 : 1;
3288	}
3289
3290	static int handleConvertDDImage(int argc, char *argv[])
3291	{
3292	#ifdef RT_OS_LINUX
3293	const bool fReadFromStdIn = (argc >= 1) && !strcmp(argv[0], "stdin");
3294	#else
3295	const bool fReadFromStdIn = false;
3296	#endif
3297
3298	if ((!fReadFromStdIn && argc != 2) \|\| (fReadFromStdIn && argc != 3))
3299	return errorSyntax(USAGE_CONVERTDD, "Incorrect number of parameters");
3300
3301	RTPrintf("Converting VDI: from DD image file=\"%s\" to file=\"%s\"...\n",
3302	argv[0], argv[1]);
3303
3304	/* open raw image file. */
3305	RTFILE File;
3306	int rc = VINF_SUCCESS;
3307	if (fReadFromStdIn)
3308	File = 0;
3309	else
3310	rc = RTFileOpen(&File, argv[0], RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE);
3311	if (VBOX_FAILURE(rc))
3312	{
3313	RTPrintf("File=\"%s\" open error: %Rrf\n", argv[0], rc);
3314	return rc;
3315	}
3316
3317	uint64_t cbFile;
3318	/* get image size. */
3319	if (fReadFromStdIn)
3320	cbFile = RTStrToUInt64(argv[2]);
3321	else
3322	rc = RTFileGetSize(File, &cbFile);
3323	if (VBOX_SUCCESS(rc))
3324	{
3325	RTPrintf("Creating fixed image with size %RU64 bytes (%RU64MB)...\n", cbFile, (cbFile + _1M - 1) / _1M);
3326	char pszComment[256];
3327	RTStrPrintf(pszComment, sizeof(pszComment), "Converted image from %s", argv[0]);
3328	rc = VDICreateBaseImage(argv[1],
3329	VDI_IMAGE_TYPE_FIXED,
3330	cbFile,
3331	pszComment, NULL, NULL);
3332	if (VBOX_SUCCESS(rc))
3333	{
3334	PVDIDISK pVdi = VDIDiskCreate();
3335	rc = VDIDiskOpenImage(pVdi, argv[1], VDI_OPEN_FLAGS_NORMAL);
3336	if (VBOX_SUCCESS(rc))
3337	{
3338	/* alloc work buffer. */
3339	size_t cbBuffer = VDIDiskGetBufferSize(pVdi);
3340	void *pvBuf = RTMemAlloc(cbBuffer);
3341	if (pvBuf)
3342	{
3343	uint64_t offFile = 0;
3344	while (offFile < cbFile)
3345	{
3346	size_t cbRead = 0;
3347	size_t cbToRead = cbFile - offFile >= (uint64_t) cbBuffer ?
3348	cbBuffer : (size_t) (cbFile - offFile);
3349	rc = RTFileRead(File, pvBuf, cbToRead, &cbRead);
3350	if (VBOX_FAILURE(rc) \|\| !cbRead)
3351	break;
3352	rc = VDIDiskWrite(pVdi, offFile, pvBuf, cbRead);
3353	if (VBOX_FAILURE(rc))
3354	break;
3355	offFile += cbRead;
3356	}
3357
3358	RTMemFree(pvBuf);
3359	}
3360	else
3361	rc = VERR_NO_MEMORY;
3362
3363	VDIDiskCloseImage(pVdi);
3364	}
3365
3366	if (VBOX_FAILURE(rc))
3367	{
3368	/* delete image on error */
3369	RTPrintf("Failed (%Vrc)!\n", rc);
3370	VDIDeleteImage(argv[1]);
3371	}
3372	}
3373	else
3374	RTPrintf("Failed to create output file (%Vrc)!\n", rc);
3375	}
3376	RTFileClose(File);
3377
3378	return rc;
3379	}
3380
3381	static int handleAddiSCSIDisk(int argc, char *argv[],
3382	ComPtr <IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
3383	{
3384	HRESULT rc;
3385	Bstr server;
3386	Bstr target;
3387	uint16_t port = UINT16_MAX;
3388	uint64_t lun = UINT64_MAX;
3389	Bstr username;
3390	Bstr password;
3391	Bstr comment;
3392
3393	/* at least server and target */
3394	if (argc < 4)
3395	{
3396	return errorSyntax(USAGE_ADDISCSIDISK, "Not enough parameters");
3397	}
3398
3399	/* let's have a closer look at the arguments */
3400	for (int i = 0; i < argc; i++)
3401	{
3402	if (strcmp(argv[i], "-server") == 0)
3403	{
3404	if (argc <= i + 1)
3405	{
3406	return errorArgument("Missing argument to '%s'", argv[i]);
3407	}
3408	i++;
3409	server = argv[i];
3410	}
3411	else if (strcmp(argv[i], "-target") == 0)
3412	{
3413	if (argc <= i + 1)
3414	{
3415	return errorArgument("Missing argument to '%s'", argv[i]);
3416	}
3417	i++;
3418	target = argv[i];
3419	}
3420	else if (strcmp(argv[i], "-port") == 0)
3421	{
3422	if (argc <= i + 1)
3423	{
3424	return errorArgument("Missing argument to '%s'", argv[i]);
3425	}
3426	i++;
3427	port = atoi(argv[i]);
3428	}
3429	else if (strcmp(argv[i], "-lun") == 0)
3430	{
3431	/** @todo move the LUN encoding algorithm into IISCSIHardDisk, add decoding */
3432	if (argc <= i + 1)
3433	{
3434	return errorArgument("Missing argument to '%s'", argv[i]);
3435	}
3436	i++;
3437	char *pszNext;
3438	int rc = RTStrToUInt64Ex(argv[i], &pszNext, 0, &lun);
3439	if (VBOX_FAILURE(rc) \|\| *pszNext != '\0' \|\| lun >= 16384)
3440	return errorArgument("Invalid LUN number '%s'", argv[i]);
3441	if (lun <= 255)
3442	{
3443	/* Assume bus identifier = 0. */
3444	lun = (lun << 48); /* uses peripheral device addressing method */
3445	}
3446	else
3447	{
3448	/* Check above already limited the LUN to 14 bits. */
3449	lun = (lun << 48) \| RT_BIT_64(62); /* uses flat space addressing method */
3450	}
3451	}
3452	else if (strcmp(argv[i], "-encodedlun") == 0)
3453	{
3454	if (argc <= i + 1)
3455	{
3456	return errorArgument("Missing argument to '%s'", argv[i]);
3457	}
3458	i++;
3459	char *pszNext;
3460	int rc = RTStrToUInt64Ex(argv[i], &pszNext, 0, &lun);
3461	if (VBOX_FAILURE(rc) \|\| *pszNext != '\0')
3462	return errorArgument("Invalid encoded LUN number '%s'", argv[i]);
3463	}
3464	else if (strcmp(argv[i], "-username") == 0)
3465	{
3466	if (argc <= i + 1)
3467	{
3468	return errorArgument("Missing argument to '%s'", argv[i]);
3469	}
3470	i++;
3471	username = argv[i];
3472	}
3473	else if (strcmp(argv[i], "-password") == 0)
3474	{
3475	if (argc <= i + 1)
3476	{
3477	return errorArgument("Missing argument to '%s'", argv[i]);
3478	}
3479	i++;
3480	password = argv[i];
3481	}
3482	else if (strcmp(argv[i], "-comment") == 0)
3483	{
3484	if (argc <= i + 1)
3485	{
3486	return errorArgument("Missing argument to '%s'", argv[i]);
3487	}
3488	i++;
3489	comment = argv[i];
3490	}
3491	else
3492	{
3493	return errorSyntax(USAGE_ADDISCSIDISK, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
3494	}
3495	}
3496
3497	/* check for required options */
3498	if (!server \|\| !target)
3499	{
3500	return errorSyntax(USAGE_ADDISCSIDISK, "Parameters -server and -target are required");
3501	}
3502
3503	ComPtr<IHardDisk> hardDisk;
3504	CHECK_ERROR(aVirtualBox, CreateHardDisk(HardDiskStorageType_ISCSIHardDisk, hardDisk.asOutParam()));
3505	if (SUCCEEDED(rc) && hardDisk)
3506	{
3507	CHECK_ERROR(hardDisk, COMSETTER(Description)(comment));
3508	ComPtr<IISCSIHardDisk> iSCSIDisk = hardDisk;
3509	CHECK_ERROR(iSCSIDisk, COMSETTER(Server)(server));
3510	if (port != UINT16_MAX)
3511	CHECK_ERROR(iSCSIDisk, COMSETTER(Port)(port));
3512	CHECK_ERROR(iSCSIDisk, COMSETTER(Target)(target));
3513	if (lun != UINT64_MAX)
3514	CHECK_ERROR(iSCSIDisk, COMSETTER(Lun)(lun));
3515	CHECK_ERROR(iSCSIDisk, COMSETTER(UserName)(username));
3516	CHECK_ERROR(iSCSIDisk, COMSETTER(Password)(password));
3517
3518	if (SUCCEEDED(rc))
3519	{
3520	CHECK_ERROR(aVirtualBox, RegisterHardDisk(hardDisk));
3521	}
3522
3523	if (SUCCEEDED(rc))
3524	{
3525	Guid guid;
3526	CHECK_ERROR(hardDisk, COMGETTER(Id)(guid.asOutParam()));
3527	RTPrintf("iSCSI disk created. UUID: %s\n", guid.toString().raw());
3528	}
3529	}
3530
3531	return SUCCEEDED(rc) ? 0 : 1;
3532	}
3533
3534	static int handleCreateVM(int argc, char *argv[],
3535	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
3536	{
3537	HRESULT rc;
3538	Bstr baseFolder;
3539	Bstr settingsFile;
3540	Bstr name;
3541	RTUUID id;
3542	bool fRegister = false;
3543
3544	for (int i = 0; i < argc; i++)
3545	{
3546	if (strcmp(argv[i], "-basefolder") == 0)
3547	{
3548	if (argc <= i + 1)
3549	{
3550	return errorArgument("Missing argument to '%s'", argv[i]);
3551	}
3552	i++;
3553	baseFolder = argv[i];
3554	}
3555	else if (strcmp(argv[i], "-settingsfile") == 0)
3556	{
3557	if (argc <= i + 1)
3558	{
3559	return errorArgument("Missing argument to '%s'", argv[i]);
3560	}
3561	i++;
3562	settingsFile = argv[i];
3563	}
3564	else if (strcmp(argv[i], "-name") == 0)
3565	{
3566	if (argc <= i + 1)
3567	{
3568	return errorArgument("Missing argument to '%s'", argv[i]);
3569	}
3570	i++;
3571	name = argv[i];
3572	}
3573	else if (strcmp(argv[i], "-uuid") == 0)
3574	{
3575	if (argc <= i + 1)
3576	{
3577	return errorArgument("Missing argument to '%s'", argv[i]);
3578	}
3579	i++;
3580	if (VBOX_FAILURE(RTUuidFromStr(&id, argv[i])))
3581	{
3582	return errorArgument("Invalid UUID format %s\n", argv[i]);
3583	}
3584	}
3585	else if (strcmp(argv[i], "-register") == 0)
3586	{
3587	fRegister = true;
3588	}
3589	else
3590	{
3591	return errorSyntax(USAGE_CREATEVM, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
3592	}
3593	}
3594	if (!name)
3595	{
3596	return errorSyntax(USAGE_CREATEVM, "Parameter -name is required");
3597	}
3598	if (!!baseFolder && !!settingsFile)
3599	{
3600	return errorSyntax(USAGE_CREATEVM, "Either -basefolder or -settingsfile must be specified");
3601	}
3602
3603	do
3604	{
3605	ComPtr<IMachine> machine;
3606
3607	if (!settingsFile)
3608	CHECK_ERROR_BREAK(virtualBox,
3609	CreateMachine(baseFolder, name, Guid(id), machine.asOutParam()));
3610	else
3611	CHECK_ERROR_BREAK(virtualBox,
3612	CreateLegacyMachine(settingsFile, name, Guid(id), machine.asOutParam()));
3613
3614	CHECK_ERROR_BREAK(machine, SaveSettings());
3615	if (fRegister)
3616	{
3617	CHECK_ERROR_BREAK(virtualBox, RegisterMachine(machine));
3618	}
3619	Guid uuid;
3620	CHECK_ERROR_BREAK(machine, COMGETTER(Id)(uuid.asOutParam()));
3621	CHECK_ERROR_BREAK(machine, COMGETTER(SettingsFilePath)(settingsFile.asOutParam()));
3622	RTPrintf("Virtual machine '%ls' is created%s.\n"
3623	"UUID: %s\n"
3624	"Settings file: '%ls'\n",
3625	name.raw(), fRegister ? " and registered" : "",
3626	uuid.toString().raw(), settingsFile.raw());
3627	}
3628	while (0);
3629
3630	return SUCCEEDED(rc) ? 0 : 1;
3631	}
3632
3633	/**
3634	* Parses a number.
3635	*
3636	* @returns Valid number on success.
3637	* @returns 0 if invalid number. All necesary bitching has been done.
3638	* @param psz Pointer to the nic number.
3639	*/
3640	static unsigned parseNum(const char psz, unsigned cMaxNum, const char name)
3641	{
3642	uint32_t u32;
3643	char *pszNext;
3644	int rc = RTStrToUInt32Ex(psz, &pszNext, 10, &u32);
3645	if ( VBOX_SUCCESS(rc)
3646	&& *pszNext == '\0'
3647	&& u32 >= 1
3648	&& u32 <= cMaxNum)
3649	return (unsigned)u32;
3650	errorArgument("Invalid %s number '%s'", name, psz);
3651	return 0;
3652	}
3653
3654	static int handleModifyVM(int argc, char *argv[],
3655	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
3656	{
3657	HRESULT rc;
3658	Bstr name;
3659	Bstr ostype;
3660	ULONG memorySize = 0;
3661	ULONG vramSize = 0;
3662	char *acpi = NULL;
3663	char *hwvirtex = NULL;
3664	char *ioapic = NULL;
3665	int monitorcount = -1;
3666	char *bioslogofadein = NULL;
3667	char *bioslogofadeout = NULL;
3668	uint32_t bioslogodisplaytime = ~0;
3669	char *bioslogoimagepath = NULL;
3670	char *biosbootmenumode = NULL;
3671	char *biossystemtimeoffset = NULL;
3672	char *biospxedebug = NULL;
3673	DeviceType_T bootDevice[4];
3674	int bootDeviceChanged[4] = { false };
3675	char *hdds[4] = {0};
3676	char *dvd = NULL;
3677	char *dvdpassthrough = NULL;
3678	char *floppy = NULL;
3679	char *audio = NULL;
3680	char *audiocontroller = NULL;
3681	char *clipboard = NULL;
3682	#ifdef VBOX_VRDP
3683	char *vrdp = NULL;
3684	uint16_t vrdpport = UINT16_MAX;
3685	char *vrdpaddress = NULL;
3686	char *vrdpauthtype = NULL;
3687	char *vrdpmulticon = NULL;
3688	#endif
3689	int fUsbEnabled = -1;
3690	int fUsbEhciEnabled = -1;
3691	char *snapshotFolder = NULL;
3692	ULONG guestMemBalloonSize = (ULONG)-1;
3693	ULONG guestStatInterval = (ULONG)-1;
3694
3695	/* VM ID + at least one parameter. Parameter arguments are checked
3696	* individually. */
3697	if (argc < 2)
3698	return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
3699
3700	/* Get the number of network adapters */
3701	ULONG NetworkAdapterCount = 0;
3702	{
3703	ComPtr <ISystemProperties> info;
3704	CHECK_ERROR_RET (virtualBox, COMGETTER(SystemProperties) (info.asOutParam()), 1);
3705	CHECK_ERROR_RET (info, COMGETTER(NetworkAdapterCount) (&NetworkAdapterCount), 1);
3706	}
3707	ULONG SerialPortCount = 0;
3708	{
3709	ComPtr <ISystemProperties> info;
3710	CHECK_ERROR_RET (virtualBox, COMGETTER(SystemProperties) (info.asOutParam()), 1);
3711	CHECK_ERROR_RET (info, COMGETTER(SerialPortCount) (&SerialPortCount), 1);
3712	}
3713
3714	std::vector <char *> nics (NetworkAdapterCount, 0);
3715	std::vector <char *> nictype (NetworkAdapterCount, 0);
3716	std::vector <char *> cableconnected (NetworkAdapterCount, 0);
3717	std::vector <char *> nictrace (NetworkAdapterCount, 0);
3718	std::vector <char *> nictracefile (NetworkAdapterCount, 0);
3719	std::vector <char *> nicspeed (NetworkAdapterCount, 0);
3720	std::vector <char *> hostifdev (NetworkAdapterCount, 0);
3721	std::vector <const char *> intnet (NetworkAdapterCount, 0);
3722	#ifdef RT_OS_LINUX
3723	std::vector <char *> tapsetup (NetworkAdapterCount, 0);
3724	std::vector <char *> tapterm (NetworkAdapterCount, 0);
3725	#endif
3726	std::vector <char *> macs (NetworkAdapterCount, 0);
3727	std::vector <char *> uarts_mode (SerialPortCount, 0);
3728	std::vector <ULONG> uarts_base (SerialPortCount, 0);
3729	std::vector <ULONG> uarts_irq (SerialPortCount, 0);
3730	std::vector <char *> uarts_path (SerialPortCount, 0);
3731
3732	for (int i = 1; i < argc; i++)
3733	{
3734	if (strcmp(argv[i], "-name") == 0)
3735	{
3736	if (argc <= i + 1)
3737	{
3738	return errorArgument("Missing argument to '%s'", argv[i]);
3739	}
3740	i++;
3741	name = argv[i];
3742	}
3743	else if (strcmp(argv[i], "-ostype") == 0)
3744	{
3745	if (argc <= i + 1)
3746	{
3747	return errorArgument("Missing argument to '%s'", argv[i]);
3748	}
3749	i++;
3750	ostype = argv[i];
3751	}
3752	else if (strcmp(argv[i], "-memory") == 0)
3753	{
3754	if (argc <= i + 1)
3755	{
3756	return errorArgument("Missing argument to '%s'", argv[i]);
3757	}
3758	i++;
3759	memorySize = atoi(argv[i]);
3760	}
3761	else if (strcmp(argv[i], "-vram") == 0)
3762	{
3763	if (argc <= i + 1)
3764	{
3765	return errorArgument("Missing argument to '%s'", argv[i]);
3766	}
3767	i++;
3768	vramSize = atoi(argv[i]);
3769	}
3770	else if (strcmp(argv[i], "-acpi") == 0)
3771	{
3772	if (argc <= i + 1)
3773	{
3774	return errorArgument("Missing argument to '%s'", argv[i]);
3775	}
3776	i++;
3777	acpi = argv[i];
3778	}
3779	else if (strcmp(argv[i], "-ioapic") == 0)
3780	{
3781	if (argc <= i + 1)
3782	{
3783	return errorArgument("Missing argument to '%s'", argv[i]);
3784	}
3785	i++;
3786	ioapic = argv[i];
3787	}
3788	else if (strcmp(argv[i], "-hwvirtex") == 0)
3789	{
3790	if (argc <= i + 1)
3791	{
3792	return errorArgument("Missing argument to '%s'", argv[i]);
3793	}
3794	i++;
3795	hwvirtex = argv[i];
3796	}
3797	else if (strcmp(argv[i], "-monitorcount") == 0)
3798	{
3799	if (argc <= i + 1)
3800	{
3801	return errorArgument("Missing argument to '%s'", argv[i]);
3802	}
3803	i++;
3804	monitorcount = atoi(argv[i]);
3805	}
3806	else if (strcmp(argv[i], "-bioslogofadein") == 0)
3807	{
3808	if (argc <= i + 1)
3809	{
3810	return errorArgument("Missing argument to '%s'", argv[i]);
3811	}
3812	i++;
3813	bioslogofadein = argv[i];
3814	}
3815	else if (strcmp(argv[i], "-bioslogofadeout") == 0)
3816	{
3817	if (argc <= i + 1)
3818	{
3819	return errorArgument("Missing argument to '%s'", argv[i]);
3820	}
3821	i++;
3822	bioslogofadeout = argv[i];
3823	}
3824	else if (strcmp(argv[i], "-bioslogodisplaytime") == 0)
3825	{
3826	if (argc <= i + 1)
3827	{
3828	return errorArgument("Missing argument to '%s'", argv[i]);
3829	}
3830	i++;
3831	bioslogodisplaytime = atoi(argv[i]);
3832	}
3833	else if (strcmp(argv[i], "-bioslogoimagepath") == 0)
3834	{
3835	if (argc <= i + 1)
3836	{
3837	return errorArgument("Missing argument to '%s'", argv[i]);
3838	}
3839	i++;
3840	bioslogoimagepath = argv[i];
3841	}
3842	else if (strcmp(argv[i], "-biosbootmenu") == 0)
3843	{
3844	if (argc <= i + 1)
3845	{
3846	return errorArgument("Missing argument to '%s'", argv[i]);
3847	}
3848	i++;
3849	biosbootmenumode = argv[i];
3850	}
3851	else if (strcmp(argv[i], "-biossystemtimeoffset") == 0)
3852	{
3853	if (argc <= i + 1)
3854	{
3855	return errorArgument("Missing argument to '%s'", argv[i]);
3856	}
3857	i++;
3858	biossystemtimeoffset = argv[i];
3859	}
3860	else if (strcmp(argv[i], "-biospxedebug") == 0)
3861	{
3862	if (argc <= i + 1)
3863	{
3864	return errorArgument("Missing argument to '%s'", argv[i]);
3865	}
3866	i++;
3867	biospxedebug = argv[i];
3868	}
3869	else if (strncmp(argv[i], "-boot", 5) == 0)
3870	{
3871	ULONG n = 0;
3872	if (!argv[i][5])
3873	{
3874	return errorSyntax(USAGE_MODIFYVM, "Missing boot slot number in '%s'", argv[i]);
3875	}
3876	if ((n = strtoul(&argv[i][5], NULL, 10)) < 1)
3877	{
3878	return errorSyntax(USAGE_MODIFYVM, "Invalid boot slot number in '%s'", argv[i]);
3879	}
3880	if (argc <= i + 1)
3881	{
3882	return errorArgument("Missing argument to '%s'", argv[i]);
3883	}
3884	i++;
3885	if (strcmp(argv[i], "none") == 0)
3886	{
3887	bootDevice[n - 1] = DeviceType_NoDevice;
3888	}
3889	else if (strcmp(argv[i], "floppy") == 0)
3890	{
3891	bootDevice[n - 1] = DeviceType_FloppyDevice;
3892	}
3893	else if (strcmp(argv[i], "dvd") == 0)
3894	{
3895	bootDevice[n - 1] = DeviceType_DVDDevice;
3896	}
3897	else if (strcmp(argv[i], "disk") == 0)
3898	{
3899	bootDevice[n - 1] = DeviceType_HardDiskDevice;
3900	}
3901	else if (strcmp(argv[i], "net") == 0)
3902	{
3903	bootDevice[n - 1] = DeviceType_NetworkDevice;
3904	}
3905	else
3906	{
3907	return errorArgument("Invalid boot device '%s'", argv[i]);
3908	}
3909	bootDeviceChanged[n - 1] = true;
3910	}
3911	else if (strcmp(argv[i], "-hda") == 0)
3912	{
3913	if (argc <= i + 1)
3914	{
3915	return errorArgument("Missing argument to '%s'", argv[i]);
3916	}
3917	i++;
3918	hdds[0] = argv[i];
3919	}
3920	else if (strcmp(argv[i], "-hdb") == 0)
3921	{
3922	if (argc <= i + 1)
3923	{
3924	return errorArgument("Missing argument to '%s'", argv[i]);
3925	}
3926	i++;
3927	hdds[1] = argv[i];
3928	}
3929	else if (strcmp(argv[i], "-hdd") == 0)
3930	{
3931	if (argc <= i + 1)
3932	{
3933	return errorArgument("Missing argument to '%s'", argv[i]);
3934	}
3935	i++;
3936	hdds[2] = argv[i];
3937	}
3938	else if (strcmp(argv[i], "-dvd") == 0)
3939	{
3940	if (argc <= i + 1)
3941	{
3942	return errorArgument("Missing argument to '%s'", argv[i]);
3943	}
3944	i++;
3945	dvd = argv[i];
3946	}
3947	else if (strcmp(argv[i], "-dvdpassthrough") == 0)
3948	{
3949	if (argc <= i + 1)
3950	{
3951	return errorArgument("Missing argument to '%s'", argv[i]);
3952	}
3953	i++;
3954	dvdpassthrough = argv[i];
3955	}
3956	else if (strcmp(argv[i], "-floppy") == 0)
3957	{
3958	if (argc <= i + 1)
3959	{
3960	return errorArgument("Missing argument to '%s'", argv[i]);
3961	}
3962	i++;
3963	floppy = argv[i];
3964	}
3965	else if (strcmp(argv[i], "-audio") == 0)
3966	{
3967	if (argc <= i + 1)
3968	{
3969	return errorArgument("Missing argument to '%s'", argv[i]);
3970	}
3971	i++;
3972	audio = argv[i];
3973	}
3974	else if (strcmp(argv[i], "-audiocontroller") == 0)
3975	{
3976	if (argc <= i + 1)
3977	{
3978	return errorArgument("Missing argument to '%s'", argv[i]);
3979	}
3980	i++;
3981	audiocontroller = argv[i];
3982	}
3983	else if (strcmp(argv[i], "-clipboard") == 0)
3984	{
3985	if (argc <= i + 1)
3986	{
3987	return errorArgument("Missing argument to '%s'", argv[i]);
3988	}
3989	i++;
3990	clipboard = argv[i];
3991	}
3992	else if (strncmp(argv[i], "-cableconnected", 15) == 0)
3993	{
3994	unsigned n = parseNum(&argv[i][15], NetworkAdapterCount, "NIC");
3995	if (!n)
3996	return 1;
3997	if (argc <= i + 1)
3998	{
3999	return errorArgument("Missing argument to '%s'", argv[i]);
4000	}
4001	cableconnected[n - 1] = argv[i + 1];
4002	i++;
4003	}
4004	/* watch for the right order of these -nic* comparisons! */
4005	else if (strncmp(argv[i], "-nictracefile", 13) == 0)
4006	{
4007	unsigned n = parseNum(&argv[i][13], NetworkAdapterCount, "NIC");
4008	if (!n)
4009	return 1;
4010	if (argc <= i + 1)
4011	{
4012	return errorArgument("Missing argument to '%s'", argv[i]);
4013	}
4014	nictracefile[n - 1] = argv[i + 1];
4015	i++;
4016	}
4017	else if (strncmp(argv[i], "-nictrace", 9) == 0)
4018	{
4019	unsigned n = parseNum(&argv[i][9], NetworkAdapterCount, "NIC");
4020	if (!n)
4021	return 1;
4022	if (argc <= i + 1)
4023	{
4024	return errorArgument("Missing argument to '%s'", argv[i]);
4025	}
4026	nictrace[n - 1] = argv[i + 1];
4027	i++;
4028	}
4029	else if (strncmp(argv[i], "-nictype", 8) == 0)
4030	{
4031	unsigned n = parseNum(&argv[i][8], NetworkAdapterCount, "NIC");
4032	if (!n)
4033	return 1;
4034	if (argc <= i + 1)
4035	{
4036	return errorArgument("Missing argument to '%s'", argv[i]);
4037	}
4038	nictype[n - 1] = argv[i + 1];
4039	i++;
4040	}
4041	else if (strncmp(argv[i], "-nicspeed", 9) == 0)
4042	{
4043	unsigned n = parseNum(&argv[i][9], NetworkAdapterCount, "NIC");
4044	if (!n)
4045	return 1;
4046	if (argc <= i + 1)
4047	{
4048	return errorArgument("Missing argument to '%s'", argv[i]);
4049	}
4050	nicspeed[n - 1] = argv[i + 1];
4051	i++;
4052	}
4053	else if (strncmp(argv[i], "-nic", 4) == 0)
4054	{
4055	unsigned n = parseNum(&argv[i][4], NetworkAdapterCount, "NIC");
4056	if (!n)
4057	return 1;
4058	if (argc <= i + 1)
4059	{
4060	return errorArgument("Missing argument to '%s'", argv[i]);
4061	}
4062	nics[n - 1] = argv[i + 1];
4063	i++;
4064	}
4065	else if (strncmp(argv[i], "-hostifdev", 10) == 0)
4066	{
4067	unsigned n = parseNum(&argv[i][10], NetworkAdapterCount, "NIC");
4068	if (!n)
4069	return 1;
4070	if (argc <= i + 1)
4071	{
4072	return errorArgument("Missing argument to '%s'", argv[i]);
4073	}
4074	hostifdev[n - 1] = argv[i + 1];
4075	i++;
4076	}
4077	else if (strncmp(argv[i], "-intnet", 7) == 0)
4078	{
4079	unsigned n = parseNum(&argv[i][7], NetworkAdapterCount, "NIC");
4080	if (!n)
4081	return 1;
4082	if (argc <= i + 1)
4083	{
4084	return errorArgument("Missing argument to '%s'", argv[i]);
4085	}
4086	intnet[n - 1] = argv[i + 1];
4087	i++;
4088	}
4089	#ifdef RT_OS_LINUX
4090	else if (strncmp(argv[i], "-tapsetup", 9) == 0)
4091	{
4092	unsigned n = parseNum(&argv[i][9], NetworkAdapterCount, "NIC");
4093	if (!n)
4094	return 1;
4095	if (argc <= i + 1)
4096	{
4097	return errorArgument("Missing argument to '%s'", argv[i]);
4098	}
4099	tapsetup[n - 1] = argv[i + 1];
4100	i++;
4101	}
4102	else if (strncmp(argv[i], "-tapterminate", 13) == 0)
4103	{
4104	unsigned n = parseNum(&argv[i][13], NetworkAdapterCount, "NIC");
4105	if (!n)
4106	return 1;
4107	if (argc <= i + 1)
4108	{
4109	return errorArgument("Missing argument to '%s'", argv[i]);
4110	}
4111	tapterm[n - 1] = argv[i + 1];
4112	i++;
4113	}
4114	#endif /* RT_OS_LINUX */
4115	else if (strncmp(argv[i], "-macaddress", 11) == 0)
4116	{
4117	unsigned n = parseNum(&argv[i][11], NetworkAdapterCount, "NIC");
4118	if (!n)
4119	return 1;
4120	if (argc <= i + 1)
4121	{
4122	return errorArgument("Missing argument to '%s'", argv[i]);
4123	}
4124	macs[n - 1] = argv[i + 1];
4125	i++;
4126	}
4127	#ifdef VBOX_VRDP
4128	else if (strcmp(argv[i], "-vrdp") == 0)
4129	{
4130	if (argc <= i + 1)
4131	{
4132	return errorArgument("Missing argument to '%s'", argv[i]);
4133	}
4134	i++;
4135	vrdp = argv[i];
4136	}
4137	else if (strcmp(argv[i], "-vrdpport") == 0)
4138	{
4139	if (argc <= i + 1)
4140	{
4141	return errorArgument("Missing argument to '%s'", argv[i]);
4142	}
4143	i++;
4144	if (strcmp(argv[i], "default") == 0)
4145	vrdpport = 0;
4146	else
4147	vrdpport = atoi(argv[i]);
4148	}
4149	else if (strcmp(argv[i], "-vrdpaddress") == 0)
4150	{
4151	if (argc <= i + 1)
4152	{
4153	return errorArgument("Missing argument to '%s'", argv[i]);
4154	}
4155	i++;
4156	vrdpaddress = argv[i];
4157	}
4158	else if (strcmp(argv[i], "-vrdpauthtype") == 0)
4159	{
4160	if (argc <= i + 1)
4161	{
4162	return errorArgument("Missing argument to '%s'", argv[i]);
4163	}
4164	i++;
4165	vrdpauthtype = argv[i];
4166	}
4167	else if (strcmp(argv[i], "-vrdpmulticon") == 0)
4168	{
4169	if (argc <= i + 1)
4170	{
4171	return errorArgument("Missing argument to '%s'", argv[i]);
4172	}
4173	i++;
4174	vrdpmulticon = argv[i];
4175	}
4176	#endif /* VBOX_VRDP */
4177	else if (strcmp(argv[i], "-usb") == 0)
4178	{
4179	if (argc <= i + 1)
4180	{
4181	return errorArgument("Missing argument to '%s'", argv[i]);
4182	}
4183	i++;
4184	if (strcmp(argv[i], "on") == 0 \|\| strcmp(argv[i], "enable") == 0)
4185	fUsbEnabled = 1;
4186	else if (strcmp(argv[i], "off") == 0 \|\| strcmp(argv[i], "disable") == 0)
4187	fUsbEnabled = 0;
4188	else
4189	return errorArgument("Invalid -usb argument '%s'", argv[i]);
4190	}
4191	else if (strcmp(argv[i], "-usbehci") == 0)
4192	{
4193	if (argc <= i + 1)
4194	{
4195	return errorArgument("Missing argument to '%s'", argv[i]);
4196	}
4197	i++;
4198	if (strcmp(argv[i], "on") == 0 \|\| strcmp(argv[i], "enable") == 0)
4199	fUsbEhciEnabled = 1;
4200	else if (strcmp(argv[i], "off") == 0 \|\| strcmp(argv[i], "disable") == 0)
4201	fUsbEhciEnabled = 0;
4202	else
4203	return errorArgument("Invalid -usbehci argument '%s'", argv[i]);
4204	}
4205	else if (strcmp(argv[i], "-snapshotfolder") == 0)
4206	{
4207	if (argc <= i + 1)
4208	{
4209	return errorArgument("Missing argument to '%s'", argv[i]);
4210	}
4211	i++;
4212	snapshotFolder = argv[i];
4213	}
4214	else if (strncmp(argv[i], "-uartmode", 9) == 0)
4215	{
4216	unsigned n = parseNum(&argv[i][9], SerialPortCount, "UART");
4217	if (!n)
4218	return 1;
4219	i++;
4220	if (strcmp(argv[i], "disconnected") == 0)
4221	{
4222	uarts_mode[n - 1] = argv[i];
4223	}
4224	else
4225	{
4226	if (strcmp(argv[i], "server") == 0 \|\| strcmp(argv[i], "client") == 0)
4227	{
4228	uarts_mode[n - 1] = argv[i];
4229	i++;
4230	#ifdef RT_OS_WINDOWS
4231	if (strncmp(argv[i], "\\\\.\\pipe\\", 9))
4232	return errorArgument("Uart pipe must start with \\\\.\\pipe\\");
4233	#endif
4234	}
4235	else
4236	{
4237	uarts_mode[n - 1] = (char*)"device";
4238	}
4239	if (argc <= i)
4240	{
4241	return errorArgument("Missing argument to -uartmode");
4242	}
4243	uarts_path[n - 1] = argv[i];
4244	}
4245	}
4246	else if (strncmp(argv[i], "-uart", 5) == 0)
4247	{
4248	unsigned n = parseNum(&argv[i][5], SerialPortCount, "UART");
4249	if (!n)
4250	return 1;
4251	if (argc <= i + 1)
4252	{
4253	return errorArgument("Missing argument to '%s'", argv[i]);
4254	}
4255	i++;
4256	if (strcmp(argv[i], "off") == 0 \|\| strcmp(argv[i], "disable") == 0)
4257	{
4258	uarts_base[n - 1] = (ULONG)-1;
4259	}
4260	else
4261	{
4262	if (argc <= i + 1)
4263	{
4264	return errorArgument("Missing argument to '%s'", argv[i-1]);
4265	}
4266	uint32_t uVal;
4267	int vrc;
4268	vrc = RTStrToUInt32Ex(argv[i], NULL, 0, &uVal);
4269	if (vrc != VINF_SUCCESS \|\| uVal == 0)
4270	return errorArgument("Error parsing UART I/O base '%s'", argv[i]);
4271	uarts_base[n - 1] = uVal;
4272	i++;
4273	vrc = RTStrToUInt32Ex(argv[i], NULL, 0, &uVal);
4274	if (vrc != VINF_SUCCESS)
4275	return errorArgument("Error parsing UART IRQ '%s'", argv[i]);
4276	uarts_irq[n - 1] = uVal;
4277	}
4278	}
4279	else if (strncmp(argv[i], "-guestmemoryballoon", 19) == 0)
4280	{
4281	if (argc <= i + 1)
4282	return errorArgument("Missing argument to '%s'", argv[i]);
4283	i++;
4284	uint32_t uVal;
4285	int vrc;
4286	vrc = RTStrToUInt32Ex(argv[i], NULL, 0, &uVal);
4287	if (vrc != VINF_SUCCESS)
4288	return errorArgument("Error parsing guest memory balloon size '%s'", argv[i]);
4289	guestMemBalloonSize = uVal;
4290	}
4291	else if (strncmp(argv[i], "-gueststatisticsinterval", 24) == 0)
4292	{
4293	if (argc <= i + 1)
4294	return errorArgument("Missing argument to '%s'", argv[i]);
4295	i++;
4296	uint32_t uVal;
4297	int vrc;
4298	vrc = RTStrToUInt32Ex(argv[i], NULL, 0, &uVal);
4299	if (vrc != VINF_SUCCESS)
4300	return errorArgument("Error parsing guest statistics interval '%s'", argv[i]);
4301	guestStatInterval = uVal;
4302	}
4303	else
4304	{
4305	return errorSyntax(USAGE_MODIFYVM, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
4306	}
4307	}
4308
4309	/* try to find the given machine */
4310	ComPtr <IMachine> machine;
4311	Guid uuid (argv[0]);
4312	if (!uuid.isEmpty())
4313	{
4314	CHECK_ERROR (virtualBox, GetMachine (uuid, machine.asOutParam()));
4315	}
4316	else
4317	{
4318	CHECK_ERROR (virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
4319	if (SUCCEEDED (rc))
4320	machine->COMGETTER(Id)(uuid.asOutParam());
4321	}
4322	if (FAILED (rc))
4323	return 1;
4324
4325	/* open a session for the VM */
4326	CHECK_ERROR_RET (virtualBox, OpenSession(session, uuid), 1);
4327
4328	do
4329	{
4330	/* get the mutable session machine */
4331	session->COMGETTER(Machine)(machine.asOutParam());
4332
4333	ComPtr <IBIOSSettings> biosSettings;
4334	machine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
4335
4336	if (name)
4337	CHECK_ERROR(machine, COMSETTER(Name)(name));
4338	if (ostype)
4339	{
4340	ComPtr<IGuestOSType> guestOSType;
4341	CHECK_ERROR(virtualBox, GetGuestOSType(ostype, guestOSType.asOutParam()));
4342	if (SUCCEEDED(rc) && guestOSType)
4343	{
4344	CHECK_ERROR(machine, COMSETTER(OSTypeId)(ostype));
4345	}
4346	else
4347	{
4348	errorArgument("Invalid guest OS type '%s'", Utf8Str(ostype).raw());
4349	rc = E_FAIL;
4350	break;
4351	}
4352	}
4353	if (memorySize > 0)
4354	CHECK_ERROR(machine, COMSETTER(MemorySize)(memorySize));
4355	if (vramSize > 0)
4356	CHECK_ERROR(machine, COMSETTER(VRAMSize)(vramSize));
4357	if (acpi)
4358	{
4359	if (strcmp(acpi, "on") == 0)
4360	{
4361	CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(true));
4362	}
4363	else if (strcmp(acpi, "off") == 0)
4364	{
4365	CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(false));
4366	}
4367	else
4368	{
4369	errorArgument("Invalid -acpi argument '%s'", acpi);
4370	rc = E_FAIL;
4371	break;
4372	}
4373	}
4374	if (ioapic)
4375	{
4376	if (strcmp(ioapic, "on") == 0)
4377	{
4378	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(true));
4379	}
4380	else if (strcmp(ioapic, "off") == 0)
4381	{
4382	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(false));
4383	}
4384	else
4385	{
4386	errorArgument("Invalid -ioapic argument '%s'", ioapic);
4387	rc = E_FAIL;
4388	break;
4389	}
4390	}
4391	if (hwvirtex)
4392	{
4393	if (strcmp(hwvirtex, "on") == 0)
4394	{
4395	CHECK_ERROR(machine, COMSETTER(HWVirtExEnabled)(TriStateBool_TSTrue));
4396	}
4397	else if (strcmp(hwvirtex, "off") == 0)
4398	{
4399	CHECK_ERROR(machine, COMSETTER(HWVirtExEnabled)(TriStateBool_TSFalse));
4400	}
4401	else if (strcmp(hwvirtex, "default") == 0)
4402	{
4403	CHECK_ERROR(machine, COMSETTER(HWVirtExEnabled)(TriStateBool_TSDefault));
4404	}
4405	else
4406	{
4407	errorArgument("Invalid -hwvirtex argument '%s'", hwvirtex);
4408	rc = E_FAIL;
4409	break;
4410	}
4411	}
4412	if (monitorcount != -1)
4413	{
4414	CHECK_ERROR(machine, COMSETTER(MonitorCount)(monitorcount));
4415	}
4416	if (bioslogofadein)
4417	{
4418	if (strcmp(bioslogofadein, "on") == 0)
4419	{
4420	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(true));
4421	}
4422	else if (strcmp(bioslogofadein, "off") == 0)
4423	{
4424	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(false));
4425	}
4426	else
4427	{
4428	errorArgument("Invalid -bioslogofadein argument '%s'", bioslogofadein);
4429	rc = E_FAIL;
4430	break;
4431	}
4432	}
4433	if (bioslogofadeout)
4434	{
4435	if (strcmp(bioslogofadeout, "on") == 0)
4436	{
4437	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(true));
4438	}
4439	else if (strcmp(bioslogofadeout, "off") == 0)
4440	{
4441	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(false));
4442	}
4443	else
4444	{
4445	errorArgument("Invalid -bioslogofadeout argument '%s'", bioslogofadeout);
4446	rc = E_FAIL;
4447	break;
4448	}
4449	}
4450	if (bioslogodisplaytime != ~0U)
4451	{
4452	CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(bioslogodisplaytime));
4453	}
4454	if (bioslogoimagepath)
4455	{
4456	CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(bioslogoimagepath)));
4457	}
4458	if (biosbootmenumode)
4459	{
4460	if (strcmp(biosbootmenumode, "disabled") == 0)
4461	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
4462	else if (strcmp(biosbootmenumode, "menuonly") == 0)
4463	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
4464	else if (strcmp(biosbootmenumode, "messageandmenu") == 0)
4465	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
4466	else
4467	{
4468	errorArgument("Invalid -biosbootmenu argument '%s'", biosbootmenumode);
4469	rc = E_FAIL;
4470	break;
4471	}
4472
4473	}
4474	if (biossystemtimeoffset)
4475	{
4476	LONG64 timeOffset = RTStrToInt64(biossystemtimeoffset);
4477	CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(timeOffset));
4478	}
4479	if (biospxedebug)
4480	{
4481	if (strcmp(biospxedebug, "on") == 0)
4482	{
4483	CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(true));
4484	}
4485	else if (strcmp(biospxedebug, "off") == 0)
4486	{
4487	CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(false));
4488	}
4489	else
4490	{
4491	errorArgument("Invalid -biospxedebug argument '%s'", biospxedebug);
4492	rc = E_FAIL;
4493	break;
4494	}
4495	}
4496	for (int curBootDev = 0; curBootDev < 4; curBootDev++)
4497	{
4498	if (bootDeviceChanged[curBootDev])
4499	CHECK_ERROR(machine, SetBootOrder (curBootDev + 1, bootDevice[curBootDev]));
4500	}
4501	if (hdds[0])
4502	{
4503	if (strcmp(hdds[0], "none") == 0)
4504	{
4505	machine->DetachHardDisk(DiskControllerType_IDE0Controller, 0);
4506	}
4507	else
4508	{
4509	/* first guess is that it's a UUID */
4510	Guid uuid(hdds[0]);
4511	ComPtr<IHardDisk> hardDisk;
4512	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
4513	/* not successful? Then it must be a filename */
4514	if (!hardDisk)
4515	{
4516	CHECK_ERROR(virtualBox, OpenHardDisk(Bstr(hdds[0]), hardDisk.asOutParam()));
4517	if (SUCCEEDED(rc) && hardDisk)
4518	{
4519	/* first check if it's already registered */
4520	Guid hddUUID;
4521	hardDisk->COMGETTER(Id)(hddUUID.asOutParam());
4522	ComPtr<IHardDisk> registeredHDD;
4523	rc = virtualBox->GetHardDisk(hddUUID, registeredHDD.asOutParam());
4524	if (SUCCEEDED(rc) && registeredHDD)
4525	hardDisk = registeredHDD;
4526	else
4527	{
4528	/* it has to be registered */
4529	CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));
4530	if (FAILED(rc))
4531	break;
4532	}
4533	}
4534	}
4535	if (hardDisk)
4536	{
4537	hardDisk->COMGETTER(Id)(uuid.asOutParam());
4538	CHECK_ERROR(machine, AttachHardDisk(uuid, DiskControllerType_IDE0Controller, 0));
4539	}
4540	else
4541	rc = E_FAIL;
4542	if (FAILED(rc))
4543	break;
4544	}
4545	}
4546	if (hdds[1])
4547	{
4548	if (strcmp(hdds[1], "none") == 0)
4549	{
4550	machine->DetachHardDisk(DiskControllerType_IDE0Controller, 1);
4551	}
4552	else
4553	{
4554	/* first guess is that it's a UUID */
4555	Guid uuid(hdds[1]);
4556	ComPtr<IHardDisk> hardDisk;
4557	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
4558	/* not successful? Then it must be a filename */
4559	if (!hardDisk)
4560	{
4561	CHECK_ERROR(virtualBox, OpenHardDisk(Bstr(hdds[1]), hardDisk.asOutParam()));
4562	if (SUCCEEDED(rc) && hardDisk)
4563	{
4564	/* first check if it's already registered */
4565	Guid hddUUID;
4566	hardDisk->COMGETTER(Id)(hddUUID.asOutParam());
4567	ComPtr<IHardDisk> registeredHDD;
4568	rc = virtualBox->GetHardDisk(hddUUID, registeredHDD.asOutParam());
4569	if (SUCCEEDED(rc) && registeredHDD)
4570	hardDisk = registeredHDD;
4571	else
4572	{
4573	/* it has to be registered */
4574	CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));
4575	if (FAILED(rc))
4576	break;
4577	}
4578	}
4579	}
4580	if (hardDisk)
4581	{
4582	hardDisk->COMGETTER(Id)(uuid.asOutParam());
4583	CHECK_ERROR(machine, AttachHardDisk(uuid, DiskControllerType_IDE0Controller, 1));
4584	}
4585	else
4586	rc = E_FAIL;
4587	if (FAILED(rc))
4588	break;
4589	}
4590	}
4591	if (hdds[2])
4592	{
4593	if (strcmp(hdds[2], "none") == 0)
4594	{
4595	machine->DetachHardDisk(DiskControllerType_IDE1Controller, 1);
4596	}
4597	else
4598	{
4599	/* first guess is that it's a UUID */
4600	Guid uuid(hdds[2]);
4601	ComPtr<IHardDisk> hardDisk;
4602	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
4603	/* not successful? Then it must be a filename */
4604	if (!hardDisk)
4605	{
4606	CHECK_ERROR(virtualBox, OpenHardDisk(Bstr(hdds[2]), hardDisk.asOutParam()));
4607	if (SUCCEEDED(rc) && hardDisk)
4608	{
4609	/* first check if it's already registered */
4610	Guid hddUUID;
4611	hardDisk->COMGETTER(Id)(hddUUID.asOutParam());
4612	ComPtr<IHardDisk> registeredHDD;
4613	rc = virtualBox->GetHardDisk(hddUUID, registeredHDD.asOutParam());
4614	if (SUCCEEDED(rc) && registeredHDD)
4615	hardDisk = registeredHDD;
4616	else
4617	{
4618	/* it has to be registered */
4619	CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));
4620	if (FAILED(rc))
4621	break;
4622	}
4623	}
4624	}
4625	if (hardDisk)
4626	{
4627	hardDisk->COMGETTER(Id)(uuid.asOutParam());
4628	CHECK_ERROR(machine, AttachHardDisk(uuid, DiskControllerType_IDE1Controller, 1));
4629	}
4630	else
4631	rc = E_FAIL;
4632	if (FAILED(rc))
4633	break;
4634	}
4635	}
4636	if (dvd)
4637	{
4638	ComPtr<IDVDDrive> dvdDrive;
4639	machine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
4640	ASSERT(dvdDrive);
4641
4642	/* unmount? */
4643	if (strcmp(dvd, "none") == 0)
4644	{
4645	CHECK_ERROR(dvdDrive, Unmount());
4646	}
4647	/* host drive? */
4648	else if (strncmp(dvd, "host:", 5) == 0)
4649	{
4650	ComPtr<IHost> host;
4651	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
4652	ComPtr<IHostDVDDriveCollection> hostDVDs;
4653	CHECK_ERROR(host, COMGETTER(DVDDrives)(hostDVDs.asOutParam()));
4654	ComPtr<IHostDVDDrive> hostDVDDrive;
4655	rc = hostDVDs->FindByName(Bstr(dvd + 5), hostDVDDrive.asOutParam());
4656	if (!hostDVDDrive)
4657	{
4658	/* 2nd try: try with the real name, important on Linux+libhal */
4659	char szPathReal[RTPATH_MAX];
4660	if (VBOX_FAILURE(RTPathReal(dvd + 5, szPathReal, sizeof(szPathReal))))
4661	{
4662	errorArgument("Invalid host DVD drive name");
4663	rc = E_FAIL;
4664	break;
4665	}
4666	rc = hostDVDs->FindByName(Bstr(szPathReal), hostDVDDrive.asOutParam());
4667	if (!hostDVDDrive)
4668	{
4669	errorArgument("Invalid host DVD drive name");
4670	rc = E_FAIL;
4671	break;
4672	}
4673	}
4674	CHECK_ERROR(dvdDrive, CaptureHostDrive(hostDVDDrive));
4675	}
4676	else
4677	{
4678	/* first assume it's a UUID */
4679	Guid uuid(dvd);
4680	ComPtr<IDVDImage> dvdImage;
4681	rc = virtualBox->GetDVDImage(uuid, dvdImage.asOutParam());
4682	if (FAILED(rc) \|\| !dvdImage)
4683	{
4684	/* must be a filename, check if it's in the collection */
4685	ComPtr<IDVDImageCollection> dvdImages;
4686	virtualBox->COMGETTER(DVDImages)(dvdImages.asOutParam());
4687	rc = dvdImages->FindByPath(Bstr(dvd), dvdImage.asOutParam());
4688	/* not registered, do that on the fly */
4689	if (!dvdImage)
4690	{
4691	Guid emptyUUID;
4692	CHECK_ERROR(virtualBox, OpenDVDImage(Bstr(dvd), emptyUUID, dvdImage.asOutParam()));
4693	if (SUCCEEDED(rc) && dvdImage)
4694	{
4695	/* time to register the image */
4696	CHECK_ERROR(virtualBox, RegisterDVDImage(dvdImage));
4697	}
4698	}
4699	}
4700	if (!dvdImage)
4701	{
4702	rc = E_FAIL;
4703	break;
4704	}
4705
4706	dvdImage->COMGETTER(Id)(uuid.asOutParam());
4707	CHECK_ERROR(dvdDrive, MountImage(uuid));
4708	}
4709	}
4710	if (dvdpassthrough)
4711	{
4712	ComPtr<IDVDDrive> dvdDrive;
4713	machine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
4714	ASSERT(dvdDrive);
4715
4716	CHECK_ERROR(dvdDrive, COMSETTER(Passthrough)(strcmp(dvdpassthrough, "on") == 0));
4717	}
4718	if (floppy)
4719	{
4720	ComPtr<IFloppyDrive> floppyDrive;
4721	machine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
4722	ASSERT(floppyDrive);
4723
4724	/* disable? */
4725	if (strcmp(floppy, "disabled") == 0)
4726	{
4727	/* disable the controller */
4728	CHECK_ERROR(floppyDrive, COMSETTER(Enabled)(false));
4729	}
4730	else
4731	{
4732	/* enable the controller */
4733	CHECK_ERROR(floppyDrive, COMSETTER(Enabled)(true));
4734
4735	/* unmount? */
4736	if (strcmp(floppy, "empty") == 0)
4737	{
4738	CHECK_ERROR(floppyDrive, Unmount());
4739	}
4740	/* host drive? */
4741	else if (strncmp(floppy, "host:", 5) == 0)
4742	{
4743	ComPtr<IHost> host;
4744	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
4745	ComPtr<IHostFloppyDriveCollection> hostFloppies;
4746	CHECK_ERROR(host, COMGETTER(FloppyDrives)(hostFloppies.asOutParam()));
4747	ComPtr<IHostFloppyDrive> hostFloppyDrive;
4748	rc = hostFloppies->FindByName(Bstr(floppy + 5), hostFloppyDrive.asOutParam());
4749	if (!hostFloppyDrive)
4750	{
4751	errorArgument("Invalid host floppy drive name");
4752	rc = E_FAIL;
4753	break;
4754	}
4755	CHECK_ERROR(floppyDrive, CaptureHostDrive(hostFloppyDrive));
4756	}
4757	else
4758	{
4759	/* first assume it's a UUID */
4760	Guid uuid(floppy);
4761	ComPtr<IFloppyImage> floppyImage;
4762	rc = virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
4763	if (FAILED(rc) \|\| !floppyImage)
4764	{
4765	/* must be a filename */
4766	Guid emptyUUID;
4767	CHECK_ERROR(virtualBox, OpenFloppyImage(Bstr(floppy), emptyUUID, floppyImage.asOutParam()));
4768	if (SUCCEEDED(rc) && floppyImage)
4769	{
4770	/** @todo first iterate through the collection and try to find the image */
4771	/* time to register the image */
4772	CHECK_ERROR(virtualBox, RegisterFloppyImage(floppyImage));
4773	}
4774	}
4775	if (!floppyImage)
4776	{
4777	rc = E_FAIL;
4778	break;
4779	}
4780
4781	floppyImage->COMGETTER(Id)(uuid.asOutParam());
4782	CHECK_ERROR(floppyDrive, MountImage(uuid));
4783	}
4784	}
4785	}
4786	if (audio \|\| audiocontroller)
4787	{
4788	ComPtr<IAudioAdapter> audioAdapter;
4789	machine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
4790	ASSERT(audioAdapter);
4791
4792	if (audio)
4793	{
4794	/* disable? */
4795	if (strcmp(audio, "none") == 0)
4796	{
4797	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
4798	}
4799	else if (strcmp(audio, "null") == 0)
4800	{
4801	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_NullAudioDriver));
4802	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4803	}
4804	#ifdef RT_OS_WINDOWS
4805	#ifdef VBOX_WITH_WINMM
4806	else if (strcmp(audio, "winmm") == 0)
4807	{
4808	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WINMMAudioDriver));
4809	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4810	}
4811	#endif
4812	else if (strcmp(audio, "dsound") == 0)
4813	{
4814	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DSOUNDAudioDriver));
4815	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4816	}
4817	#endif /* RT_OS_WINDOWS */
4818	#ifdef RT_OS_LINUX
4819	else if (strcmp(audio, "oss") == 0)
4820	{
4821	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSSAudioDriver));
4822	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4823	}
4824	# ifdef VBOX_WITH_ALSA
4825	else if (strcmp(audio, "alsa") == 0)
4826	{
4827	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSAAudioDriver));
4828	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4829	}
4830	# endif
4831	# ifdef VBOX_WITH_PULSE
4832	else if (strcmp(audio, "pulse") == 0)
4833	{
4834	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_PulseAudioDriver));
4835	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4836	}
4837	# endif
4838	#endif /* !RT_OS_LINUX */
4839	#ifdef RT_OS_DARWIN
4840	else if (strcmp(audio, "coreaudio") == 0)
4841	{
4842	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudioDriver));
4843	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
4844	}
4845
4846	#endif /* !RT_OS_DARWIN */
4847	else
4848	{
4849	errorArgument("Invalid -audio argument '%s'", audio);
4850	rc = E_FAIL;
4851	break;
4852	}
4853	}
4854	if (audiocontroller)
4855	{
4856	if (strcmp(audiocontroller, "sb16") == 0)
4857	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
4858	else if (strcmp(audiocontroller, "ac97") == 0)
4859	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
4860	else
4861	{
4862	errorArgument("Invalid -audiocontroller argument '%s'", audiocontroller);
4863	rc = E_FAIL;
4864	break;
4865	}
4866	}
4867	}
4868	/* Shared clipboard state */
4869	if (clipboard)
4870	{
4871	/* ComPtr<IClipboardMode> clipboardMode;
4872	machine->COMGETTER(ClipboardMode)(clipboardMode.asOutParam());
4873	ASSERT(clipboardMode);
4874	*/
4875	if (strcmp(clipboard, "disabled") == 0)
4876	{
4877	CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_ClipDisabled));
4878	}
4879	else if (strcmp(clipboard, "hosttoguest") == 0)
4880	{
4881	CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_ClipHostToGuest));
4882	}
4883	else if (strcmp(clipboard, "guesttohost") == 0)
4884	{
4885	CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_ClipGuestToHost));
4886	}
4887	else if (strcmp(clipboard, "bidirectional") == 0)
4888	{
4889	CHECK_ERROR(machine, COMSETTER(ClipboardMode)(ClipboardMode_ClipBidirectional));
4890	}
4891	else
4892	{
4893	errorArgument("Invalid -clipboard argument '%s'", clipboard);
4894	rc = E_FAIL;
4895	break;
4896	}
4897	}
4898	/* iterate through all possible NICs */
4899	for (ULONG n = 0; n < NetworkAdapterCount; n ++)
4900	{
4901	ComPtr<INetworkAdapter> nic;
4902	CHECK_ERROR_RET (machine, GetNetworkAdapter (n, nic.asOutParam()), 1);
4903
4904	ASSERT(nic);
4905
4906	/* something about the NIC? */
4907	if (nics[n])
4908	{
4909	if (strcmp(nics[n], "none") == 0)
4910	{
4911	CHECK_ERROR_RET(nic, COMSETTER(Enabled) (FALSE), 1);
4912	}
4913	else if (strcmp(nics[n], "null") == 0)
4914	{
4915	CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
4916	CHECK_ERROR_RET(nic, Detach(), 1);
4917	}
4918	else if (strcmp(nics[n], "nat") == 0)
4919	{
4920	CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
4921	CHECK_ERROR_RET(nic, AttachToNAT(), 1);
4922	}
4923	else if (strcmp(nics[n], "hostif") == 0)
4924	{
4925	CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
4926	CHECK_ERROR_RET(nic, AttachToHostInterface(), 1);
4927	}
4928	else if (strcmp(nics[n], "intnet") == 0)
4929	{
4930	CHECK_ERROR_RET(nic, COMSETTER(Enabled) (TRUE), 1);
4931	CHECK_ERROR_RET(nic, AttachToInternalNetwork(), 1);
4932	}
4933	else
4934	{
4935	errorArgument("Invalid type '%s' specfied for NIC %lu", nics[n], n + 1);
4936	rc = E_FAIL;
4937	break;
4938	}
4939	}
4940
4941	/* something about the NIC type? */
4942	if (nictype[n])
4943	{
4944	if (strcmp(nictype[n], "Am79C970A") == 0)
4945	{
4946	CHECK_ERROR_RET(nic, COMSETTER(AdapterType)(NetworkAdapterType_NetworkAdapterAm79C970A), 1);
4947	}
4948	else if (strcmp(nictype[n], "Am79C973") == 0)
4949	{
4950	CHECK_ERROR_RET(nic, COMSETTER(AdapterType)(NetworkAdapterType_NetworkAdapterAm79C973), 1);
4951	}
4952	else
4953	{
4954	errorArgument("Invalid NIC type '%s' specified for NIC %lu", nictype[n], n + 1);
4955	rc = E_FAIL;
4956	break;
4957	}
4958	}
4959
4960	/* something about the MAC address? */
4961	if (macs[n])
4962	{
4963	/* generate one? */
4964	if (strcmp(macs[n], "auto") == 0)
4965	{
4966	CHECK_ERROR_RET(nic, COMSETTER(MACAddress)(NULL), 1);
4967	}
4968	else
4969	{
4970	CHECK_ERROR_RET(nic, COMSETTER(MACAddress)(Bstr(macs[n])), 1);
4971	}
4972	}
4973
4974	/* something about the reported link speed? */
4975	if (nicspeed[n])
4976	{
4977	uint32_t u32LineSpeed;
4978
4979	u32LineSpeed = atoi(nicspeed[n]);
4980
4981	if (u32LineSpeed < 1000 \|\| u32LineSpeed > 4000000)
4982	{
4983	errorArgument("Invalid -nicspeed%lu argument '%s'", n + 1, nicspeed[n]);
4984	rc = E_FAIL;
4985	break;
4986	}
4987	CHECK_ERROR_RET(nic, COMSETTER(LineSpeed)(u32LineSpeed), 1);
4988	}
4989
4990	/* the link status flag? */
4991	if (cableconnected[n])
4992	{
4993	if (strcmp(cableconnected[n], "on") == 0)
4994	{
4995	CHECK_ERROR_RET(nic, COMSETTER(CableConnected)(TRUE), 1);
4996	}
4997	else if (strcmp(cableconnected[n], "off") == 0)
4998	{
4999	CHECK_ERROR_RET(nic, COMSETTER(CableConnected)(FALSE), 1);
5000	}
5001	else
5002	{
5003	errorArgument("Invalid -cableconnected%lu argument '%s'", n + 1, cableconnected[n]);
5004	rc = E_FAIL;
5005	break;
5006	}
5007	}
5008
5009	/* the trace flag? */
5010	if (nictrace[n])
5011	{
5012	if (strcmp(nictrace[n], "on") == 0)
5013	{
5014	CHECK_ERROR_RET(nic, COMSETTER(TraceEnabled)(TRUE), 1);
5015	}
5016	else if (strcmp(nictrace[n], "off") == 0)
5017	{
5018	CHECK_ERROR_RET(nic, COMSETTER(TraceEnabled)(FALSE), 1);
5019	}
5020	else
5021	{
5022	errorArgument("Invalid -nictrace%lu argument '%s'", n + 1, nictrace[n]);
5023	rc = E_FAIL;
5024	break;
5025	}
5026	}
5027
5028	/* the tracefile flag? */
5029	if (nictracefile[n])
5030	{
5031	CHECK_ERROR_RET(nic, COMSETTER(TraceFile)(Bstr(nictracefile[n])), 1);
5032	}
5033
5034	/* the host interface device? */
5035	if (hostifdev[n])
5036	{
5037	/* remove it? */
5038	if (strcmp(hostifdev[n], "none") == 0)
5039	{
5040	CHECK_ERROR_RET(nic, COMSETTER(HostInterface)(NULL), 1);
5041	}
5042	else
5043	{
5044	CHECK_ERROR_RET(nic, COMSETTER(HostInterface)(Bstr(hostifdev[n])), 1);
5045	}
5046	}
5047
5048	/* the internal network name? */
5049	if (intnet[n])
5050	{
5051	/* remove it? */
5052	if (strcmp(intnet[n], "none") == 0)
5053	{
5054	CHECK_ERROR_RET(nic, COMSETTER(InternalNetwork)(NULL), 1);
5055	}
5056	else
5057	{
5058	CHECK_ERROR_RET(nic, COMSETTER(InternalNetwork)(Bstr(intnet[n])), 1);
5059	}
5060	}
5061
5062	#ifdef RT_OS_LINUX
5063	/* the TAP setup application? */
5064	if (tapsetup[n])
5065	{
5066	/* remove it? */
5067	if (strcmp(tapsetup[n], "none") == 0)
5068	{
5069	CHECK_ERROR_RET(nic, COMSETTER(TAPSetupApplication)(NULL), 1);
5070	}
5071	else
5072	{
5073	CHECK_ERROR_RET(nic, COMSETTER(TAPSetupApplication)(Bstr(tapsetup[n])), 1);
5074	}
5075	}
5076
5077	/* the TAP terminate application? */
5078	if (tapterm[n])
5079	{
5080	/* remove it? */
5081	if (strcmp(tapterm[n], "none") == 0)
5082	{
5083	CHECK_ERROR_RET(nic, COMSETTER(TAPTerminateApplication)(NULL), 1);
5084	}
5085	else
5086	{
5087	CHECK_ERROR_RET(nic, COMSETTER(TAPTerminateApplication)(Bstr(tapterm[n])), 1);
5088	}
5089	}
5090	#endif /* RT_OS_LINUX */
5091
5092	}
5093	if (FAILED(rc))
5094	break;
5095
5096	/* iterate through all possible serial ports */
5097	for (ULONG n = 0; n < SerialPortCount; n ++)
5098	{
5099	ComPtr<ISerialPort> uart;
5100	CHECK_ERROR_RET (machine, GetSerialPort (n, uart.asOutParam()), 1);
5101
5102	ASSERT(uart);
5103
5104	if (uarts_base[n])
5105	{
5106	if (uarts_base[n] == (ULONG)-1)
5107	{
5108	CHECK_ERROR_RET(uart, COMSETTER(Enabled) (FALSE), 1);
5109	}
5110	else
5111	{
5112	CHECK_ERROR_RET(uart, COMSETTER(IOBase) (uarts_base[n]), 1);
5113	CHECK_ERROR_RET(uart, COMSETTER(IRQ) (uarts_irq[n]), 1);
5114	CHECK_ERROR_RET(uart, COMSETTER(Enabled) (TRUE), 1);
5115	}
5116	}
5117	if (uarts_mode[n])
5118	{
5119	if (strcmp(uarts_mode[n], "disconnected") == 0)
5120	{
5121	CHECK_ERROR_RET(uart, COMSETTER(HostMode) (PortMode_DisconnectedPort), 1);
5122	}
5123	else
5124	{
5125	if (strcmp(uarts_mode[n], "server") == 0)
5126	{
5127	CHECK_ERROR_RET(uart, COMSETTER(HostMode) (PortMode_HostPipePort), 1);
5128	CHECK_ERROR_RET(uart, COMSETTER(Server) (TRUE), 1);
5129	}
5130	else if (strcmp(uarts_mode[n], "client") == 0)
5131	{
5132	CHECK_ERROR_RET(uart, COMSETTER(HostMode) (PortMode_HostPipePort), 1);
5133	CHECK_ERROR_RET(uart, COMSETTER(Server) (FALSE), 1);
5134	}
5135	else
5136	{
5137	CHECK_ERROR_RET(uart, COMSETTER(HostMode) (PortMode_HostDevicePort), 1);
5138	}
5139	CHECK_ERROR_RET(uart, COMSETTER(Path) (Bstr(uarts_path[n])), 1);
5140	}
5141	}
5142	}
5143	if (FAILED(rc))
5144	break;
5145
5146	#ifdef VBOX_VRDP
5147	if (vrdp \|\| (vrdpport != UINT16_MAX) \|\| vrdpaddress \|\| vrdpauthtype \|\| vrdpmulticon)
5148	{
5149	ComPtr<IVRDPServer> vrdpServer;
5150	machine->COMGETTER(VRDPServer)(vrdpServer.asOutParam());
5151	ASSERT(vrdpServer);
5152	if (vrdpServer)
5153	{
5154	if (vrdp)
5155	{
5156	if (strcmp(vrdp, "on") == 0)
5157	{
5158	CHECK_ERROR(vrdpServer, COMSETTER(Enabled)(true));
5159	}
5160	else if (strcmp(vrdp, "off") == 0)
5161	{
5162	CHECK_ERROR(vrdpServer, COMSETTER(Enabled)(false));
5163	}
5164	else
5165	{
5166	errorArgument("Invalid -vrdp argument '%s'", vrdp);
5167	rc = E_FAIL;
5168	break;
5169	}
5170	}
5171	if (vrdpport != UINT16_MAX)
5172	{
5173	CHECK_ERROR(vrdpServer, COMSETTER(Port)(vrdpport));
5174	}
5175	if (vrdpaddress)
5176	{
5177	CHECK_ERROR(vrdpServer, COMSETTER(NetAddress)(Bstr(vrdpaddress)));
5178	}
5179	if (vrdpauthtype)
5180	{
5181	if (strcmp(vrdpauthtype, "null") == 0)
5182	{
5183	CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_VRDPAuthNull));
5184	}
5185	else if (strcmp(vrdpauthtype, "external") == 0)
5186	{
5187	CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_VRDPAuthExternal));
5188	}
5189	else if (strcmp(vrdpauthtype, "guest") == 0)
5190	{
5191	CHECK_ERROR(vrdpServer, COMSETTER(AuthType)(VRDPAuthType_VRDPAuthGuest));
5192	}
5193	else
5194	{
5195	errorArgument("Invalid -vrdpauthtype argument '%s'", vrdpauthtype);
5196	rc = E_FAIL;
5197	break;
5198	}
5199	}
5200	if (vrdpmulticon)
5201	{
5202	if (strcmp(vrdpmulticon, "on") == 0)
5203	{
5204	CHECK_ERROR(vrdpServer, COMSETTER(AllowMultiConnection)(true));
5205	}
5206	else if (strcmp(vrdpmulticon, "off") == 0)
5207	{
5208	CHECK_ERROR(vrdpServer, COMSETTER(AllowMultiConnection)(false));
5209	}
5210	else
5211	{
5212	errorArgument("Invalid -vrdpmulticon argument '%s'", vrdpmulticon);
5213	rc = E_FAIL;
5214	break;
5215	}
5216	}
5217	}
5218	}
5219	#endif /* VBOX_VRDP */
5220
5221	/*
5222	* USB enable/disable
5223	*/
5224	if (fUsbEnabled != -1)
5225	{
5226	ComPtr<IUSBController> UsbCtl;
5227	CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
5228	if (SUCCEEDED(rc))
5229	{
5230	CHECK_ERROR(UsbCtl, COMSETTER(Enabled)(!!fUsbEnabled));
5231	}
5232	}
5233	/*
5234	* USB EHCI enable/disable
5235	*/
5236	if (fUsbEhciEnabled != -1)
5237	{
5238	ComPtr<IUSBController> UsbCtl;
5239	CHECK_ERROR(machine, COMGETTER(USBController)(UsbCtl.asOutParam()));
5240	if (SUCCEEDED(rc))
5241	{
5242	CHECK_ERROR(UsbCtl, COMSETTER(EnabledEhci)(!!fUsbEhciEnabled));
5243	}
5244	}
5245
5246	if (snapshotFolder)
5247	{
5248	if (strcmp(snapshotFolder, "default") == 0)
5249	{
5250	CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(NULL));
5251	}
5252	else
5253	{
5254	CHECK_ERROR(machine, COMSETTER(SnapshotFolder)(Bstr(snapshotFolder)));
5255	}
5256	}
5257
5258	if (guestMemBalloonSize != (ULONG)-1)
5259	CHECK_ERROR(machine, COMSETTER(MemoryBalloonSize)(guestMemBalloonSize));
5260
5261	if (guestStatInterval != (ULONG)-1)
5262	CHECK_ERROR(machine, COMSETTER(StatisticsUpdateInterval)(guestStatInterval));
5263
5264	/* commit changes */
5265	CHECK_ERROR(machine, SaveSettings());
5266	}
5267	while (0);
5268
5269	/* it's important to always close sessions */
5270	session->Close();
5271
5272	return SUCCEEDED(rc) ? 0 : 1;
5273	}
5274
5275	static int handleStartVM(int argc, char *argv[],
5276	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
5277	{
5278	HRESULT rc;
5279
5280	if (argc < 1)
5281	{
5282	return errorSyntax(USAGE_STARTVM, "Not enough parameters");
5283	}
5284
5285	ComPtr<IMachine> machine;
5286	/* assume it's a UUID */
5287	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
5288	if (FAILED(rc) \|\| !machine)
5289	{
5290	/* must be a name */
5291	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
5292	}
5293	if (machine)
5294	{
5295	Guid uuid;
5296	machine->COMGETTER(Id)(uuid.asOutParam());
5297
5298	/* default to GUI session type */
5299	Bstr sessionType = "gui";
5300	/* has a session type been specified? */
5301	if ((argc > 2) && (strcmp(argv[1], "-type") == 0))
5302	{
5303	if (strcmp(argv[2], "gui") == 0)
5304	{
5305	sessionType = "gui";
5306	}
5307	else if (strcmp(argv[2], "vrdp") == 0)
5308	{
5309	sessionType = "vrdp";
5310	}
5311	else if (strcmp(argv[2], "capture") == 0)
5312	{
5313	sessionType = "capture";
5314	}
5315	else
5316	{
5317	return errorArgument("Invalid session type argument '%s'", argv[2]);
5318	}
5319	}
5320
5321	Bstr env;
5322	#ifdef RT_OS_LINUX
5323	/* make sure the VM process will start on the same display as VBoxManage */
5324	{
5325	const char *display = RTEnvGet ("DISPLAY");
5326	if (display)
5327	env = Utf8StrFmt ("DISPLAY=%s", display);
5328	}
5329	#endif
5330	ComPtr<IProgress> progress;
5331	CHECK_ERROR_RET(virtualBox, OpenRemoteSession(session, uuid, sessionType,
5332	env, progress.asOutParam()), rc);
5333	RTPrintf("Waiting for the remote session to open...\n");
5334	CHECK_ERROR_RET(progress, WaitForCompletion (-1), 1);
5335
5336	BOOL completed;
5337	CHECK_ERROR_RET(progress, COMGETTER(Completed)(&completed), rc);
5338	ASSERT(completed);
5339
5340	HRESULT resultCode;
5341	CHECK_ERROR_RET(progress, COMGETTER(ResultCode)(&resultCode), rc);
5342	if (FAILED(resultCode))
5343	{
5344	ComPtr <IVirtualBoxErrorInfo> errorInfo;
5345	CHECK_ERROR_RET(progress, COMGETTER(ErrorInfo)(errorInfo.asOutParam()), 1);
5346	ErrorInfo info (errorInfo);
5347	PRINT_ERROR_INFO(info);
5348	}
5349	else
5350	{
5351	RTPrintf("Remote session has been successfully opened.\n");
5352	}
5353	}
5354
5355	/* it's important to always close sessions */
5356	session->Close();
5357
5358	return SUCCEEDED(rc) ? 0 : 1;
5359	}
5360
5361	static int handleControlVM(int argc, char *argv[],
5362	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
5363	{
5364	HRESULT rc;
5365
5366	if (argc < 2)
5367	{
5368	return errorSyntax(USAGE_CONTROLVM, "Not enough parameters");
5369	}
5370
5371	/* try to find the given machine */
5372	ComPtr <IMachine> machine;
5373	Guid uuid (argv[0]);
5374	if (!uuid.isEmpty())
5375	{
5376	CHECK_ERROR (virtualBox, GetMachine (uuid, machine.asOutParam()));
5377	}
5378	else
5379	{
5380	CHECK_ERROR (virtualBox, FindMachine (Bstr(argv[0]), machine.asOutParam()));
5381	if (SUCCEEDED (rc))
5382	machine->COMGETTER(Id) (uuid.asOutParam());
5383	}
5384	if (FAILED (rc))
5385	return 1;
5386
5387	/* open a session for the VM */
5388	CHECK_ERROR_RET (virtualBox, OpenExistingSession (session, uuid), 1);
5389
5390	do
5391	{
5392	/* get the associated console */
5393	ComPtr<IConsole> console;
5394	CHECK_ERROR_BREAK (session, COMGETTER(Console)(console.asOutParam()));
5395	/* ... and session machine */
5396	ComPtr<IMachine> sessionMachine;
5397	CHECK_ERROR_BREAK (session, COMGETTER(Machine)(sessionMachine.asOutParam()));
5398
5399	/* which command? */
5400	if (strcmp(argv[1], "pause") == 0)
5401	{
5402	CHECK_ERROR_BREAK (console, Pause());
5403	}
5404	else if (strcmp(argv[1], "resume") == 0)
5405	{
5406	CHECK_ERROR_BREAK (console, Resume());
5407	}
5408	else if (strcmp(argv[1], "reset") == 0)
5409	{
5410	CHECK_ERROR_BREAK (console, Reset());
5411	}
5412	else if (strcmp(argv[1], "poweroff") == 0)
5413	{
5414	CHECK_ERROR_BREAK (console, PowerDown());
5415	}
5416	else if (strcmp(argv[1], "savestate") == 0)
5417	{
5418	ComPtr<IProgress> progress;
5419	CHECK_ERROR_BREAK (console, SaveState(progress.asOutParam()));
5420
5421	showProgress(progress);
5422
5423	progress->COMGETTER(ResultCode)(&rc);
5424	if (FAILED(rc))
5425	{
5426	com::ProgressErrorInfo info(progress);
5427	if (info.isBasicAvailable())
5428	{
5429	RTPrintf("Error: failed to save machine state. Error message: %lS\n", info.getText().raw());
5430	}
5431	else
5432	{
5433	RTPrintf("Error: failed to save machine state. No error message available!\n");
5434	}
5435	}
5436	}
5437	else if (strcmp(argv[1], "acpipowerbutton") == 0)
5438	{
5439	CHECK_ERROR_BREAK (console, PowerButton());
5440	}
5441	else if (strcmp(argv[1], "acpisleepbutton") == 0)
5442	{
5443	CHECK_ERROR_BREAK (console, SleepButton());
5444	}
5445	else if (strncmp(argv[1], "setlinkstate", 12) == 0)
5446	{
5447	/* Get the number of network adapters */
5448	ULONG NetworkAdapterCount = 0;
5449	ComPtr <ISystemProperties> info;
5450	CHECK_ERROR_BREAK (virtualBox, COMGETTER(SystemProperties) (info.asOutParam()));
5451	CHECK_ERROR_BREAK (info, COMGETTER(NetworkAdapterCount) (&NetworkAdapterCount));
5452
5453	unsigned n = parseNum(&argv[1][12], NetworkAdapterCount, "NIC");
5454	if (!n)
5455	{
5456	rc = E_FAIL;
5457	break;
5458	}
5459	if (argc <= 1 + 1)
5460	{
5461	errorArgument("Missing argument to '%s'", argv[1]);
5462	rc = E_FAIL;
5463	break;
5464	}
5465	/* get the corresponding network adapter */
5466	ComPtr<INetworkAdapter> adapter;
5467	CHECK_ERROR_BREAK (sessionMachine, GetNetworkAdapter(n - 1, adapter.asOutParam()));
5468	if (adapter)
5469	{
5470	if (strcmp(argv[2], "on") == 0)
5471	{
5472	CHECK_ERROR_BREAK (adapter, COMSETTER(CableConnected)(TRUE));
5473	}
5474	else if (strcmp(argv[2], "off") == 0)
5475	{
5476	CHECK_ERROR_BREAK (adapter, COMSETTER(CableConnected)(FALSE));
5477	}
5478	else
5479	{
5480	errorArgument("Invalid link state '%s'", Utf8Str(argv[2]).raw());
5481	rc = E_FAIL;
5482	break;
5483	}
5484	}
5485	}
5486	else if (strcmp (argv[1], "usbattach") == 0 \|\|
5487	strcmp (argv[1], "usbdetach") == 0)
5488	{
5489	if (argc < 3)
5490	{
5491	errorSyntax(USAGE_CONTROLVM, "Not enough parameters");
5492	rc = E_FAIL;
5493	break;
5494	}
5495
5496	bool attach = strcmp (argv[1], "usbattach") == 0;
5497
5498	Guid usbId = argv [2];
5499	if (usbId.isEmpty())
5500	{
5501	// assume address
5502	if (attach)
5503	{
5504	ComPtr <IHost> host;
5505	CHECK_ERROR_BREAK (virtualBox, COMGETTER(Host) (host.asOutParam()));
5506	ComPtr <IHostUSBDeviceCollection> coll;
5507	CHECK_ERROR_BREAK (host, COMGETTER(USBDevices) (coll.asOutParam()));
5508	ComPtr <IHostUSBDevice> dev;
5509	CHECK_ERROR_BREAK (coll, FindByAddress (Bstr (argv [2]), dev.asOutParam()));
5510	CHECK_ERROR_BREAK (dev, COMGETTER(Id) (usbId.asOutParam()));
5511	}
5512	else
5513	{
5514	ComPtr <IUSBDeviceCollection> coll;
5515	CHECK_ERROR_BREAK (console, COMGETTER(USBDevices)(coll.asOutParam()));
5516	ComPtr <IUSBDevice> dev;
5517	CHECK_ERROR_BREAK (coll, FindByAddress (Bstr (argv [2]), dev.asOutParam()));
5518	CHECK_ERROR_BREAK (dev, COMGETTER(Id) (usbId.asOutParam()));
5519	}
5520	}
5521
5522	if (attach)
5523	CHECK_ERROR_BREAK (console, AttachUSBDevice (usbId));
5524	else
5525	{
5526	ComPtr <IUSBDevice> dev;
5527	CHECK_ERROR_BREAK (console, DetachUSBDevice (usbId, dev.asOutParam()));
5528	}
5529	}
5530	else if (strcmp(argv[1], "setvideomodehint") == 0)
5531	{
5532	if (argc != 5 && argc != 6)
5533	{
5534	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5535	rc = E_FAIL;
5536	break;
5537	}
5538	uint32_t xres = atoi(argv[2]);
5539	uint32_t yres = atoi(argv[3]);
5540	uint32_t bpp = atoi(argv[4]);
5541	uint32_t displayIdx = 0;
5542	if (argc == 6)
5543	displayIdx = atoi(argv[5]);
5544
5545	ComPtr<IDisplay> display;
5546	CHECK_ERROR_BREAK(console, COMGETTER(Display)(display.asOutParam()));
5547	CHECK_ERROR_BREAK(display, SetVideoModeHint(xres, yres, bpp, displayIdx));
5548	}
5549	else if (strcmp(argv[1], "setcredentials") == 0)
5550	{
5551	bool fAllowLocalLogon = true;
5552	if (argc == 7)
5553	{
5554	if (strcmp(argv[5], "-allowlocallogon") != 0)
5555	{
5556	errorArgument("Invalid parameter '%s'", argv[5]);
5557	rc = E_FAIL;
5558	break;
5559	}
5560	if (strcmp(argv[6], "no") == 0)
5561	fAllowLocalLogon = false;
5562	}
5563	else if (argc != 5)
5564	{
5565	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5566	rc = E_FAIL;
5567	break;
5568	}
5569
5570	ComPtr<IGuest> guest;
5571	CHECK_ERROR_BREAK(console, COMGETTER(Guest)(guest.asOutParam()));
5572	CHECK_ERROR_BREAK(guest, SetCredentials(Bstr(argv[2]), Bstr(argv[3]), Bstr(argv[4]), fAllowLocalLogon));
5573	}
5574	else if (strcmp(argv[1], "dvdattach") == 0)
5575	{
5576	if (argc != 3)
5577	{
5578	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5579	rc = E_FAIL;
5580	break;
5581	}
5582	ComPtr<IDVDDrive> dvdDrive;
5583	sessionMachine->COMGETTER(DVDDrive)(dvdDrive.asOutParam());
5584	ASSERT(dvdDrive);
5585
5586	/* unmount? */
5587	if (strcmp(argv[2], "none") == 0)
5588	{
5589	CHECK_ERROR(dvdDrive, Unmount());
5590	}
5591	/* host drive? */
5592	else if (strncmp(argv[2], "host:", 5) == 0)
5593	{
5594	ComPtr<IHost> host;
5595	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
5596	ComPtr<IHostDVDDriveCollection> hostDVDs;
5597	CHECK_ERROR(host, COMGETTER(DVDDrives)(hostDVDs.asOutParam()));
5598	ComPtr<IHostDVDDrive> hostDVDDrive;
5599	rc = hostDVDs->FindByName(Bstr(argv[2] + 5), hostDVDDrive.asOutParam());
5600	if (!hostDVDDrive)
5601	{
5602	errorArgument("Invalid host DVD drive name");
5603	rc = E_FAIL;
5604	break;
5605	}
5606	CHECK_ERROR(dvdDrive, CaptureHostDrive(hostDVDDrive));
5607	}
5608	else
5609	{
5610	/* first assume it's a UUID */
5611	Guid uuid(argv[2]);
5612	ComPtr<IDVDImage> dvdImage;
5613	rc = virtualBox->GetDVDImage(uuid, dvdImage.asOutParam());
5614	if (FAILED(rc) \|\| !dvdImage)
5615	{
5616	/* must be a filename, check if it's in the collection */
5617	ComPtr<IDVDImageCollection> dvdImages;
5618	virtualBox->COMGETTER(DVDImages)(dvdImages.asOutParam());
5619	rc = dvdImages->FindByPath(Bstr(argv[2]), dvdImage.asOutParam());
5620	/* not registered, do that on the fly */
5621	if (!dvdImage)
5622	{
5623	Guid emptyUUID;
5624	CHECK_ERROR(virtualBox, OpenDVDImage(Bstr(argv[2]), emptyUUID, dvdImage.asOutParam()));
5625	if (SUCCEEDED(rc) && dvdImage)
5626	{
5627	/* time to register the image */
5628	CHECK_ERROR(virtualBox, RegisterDVDImage(dvdImage));
5629	}
5630	}
5631	}
5632	if (!dvdImage)
5633	{
5634	rc = E_FAIL;
5635	break;
5636	}
5637	dvdImage->COMGETTER(Id)(uuid.asOutParam());
5638	CHECK_ERROR(dvdDrive, MountImage(uuid));
5639	}
5640	}
5641	else if (strcmp(argv[1], "floppyattach") == 0)
5642	{
5643	if (argc != 3)
5644	{
5645	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5646	rc = E_FAIL;
5647	break;
5648	}
5649
5650	ComPtr<IFloppyDrive> floppyDrive;
5651	sessionMachine->COMGETTER(FloppyDrive)(floppyDrive.asOutParam());
5652	ASSERT(floppyDrive);
5653
5654	/* unmount? */
5655	if (strcmp(argv[2], "none") == 0)
5656	{
5657	CHECK_ERROR(floppyDrive, Unmount());
5658	}
5659	/* host drive? */
5660	else if (strncmp(argv[2], "host:", 5) == 0)
5661	{
5662	ComPtr<IHost> host;
5663	CHECK_ERROR(virtualBox, COMGETTER(Host)(host.asOutParam()));
5664	ComPtr<IHostFloppyDriveCollection> hostFloppies;
5665	CHECK_ERROR(host, COMGETTER(FloppyDrives)(hostFloppies.asOutParam()));
5666	ComPtr<IHostFloppyDrive> hostFloppyDrive;
5667	rc = hostFloppies->FindByName(Bstr(argv[2] + 5), hostFloppyDrive.asOutParam());
5668	if (!hostFloppyDrive)
5669	{
5670	errorArgument("Invalid host floppy drive name");
5671	rc = E_FAIL;
5672	break;
5673	}
5674	CHECK_ERROR(floppyDrive, CaptureHostDrive(hostFloppyDrive));
5675	}
5676	else
5677	{
5678	/* first assume it's a UUID */
5679	Guid uuid(argv[2]);
5680	ComPtr<IFloppyImage> floppyImage;
5681	rc = virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
5682	if (FAILED(rc) \|\| !floppyImage)
5683	{
5684	/* must be a filename, check if it's in the collection */
5685	ComPtr<IFloppyImageCollection> floppyImages;
5686	virtualBox->COMGETTER(FloppyImages)(floppyImages.asOutParam());
5687	rc = floppyImages->FindByPath(Bstr(argv[2]), floppyImage.asOutParam());
5688	/* not registered, do that on the fly */
5689	if (!floppyImage)
5690	{
5691	Guid emptyUUID;
5692	CHECK_ERROR(virtualBox, OpenFloppyImage(Bstr(argv[2]), emptyUUID, floppyImage.asOutParam()));
5693	if (SUCCEEDED(rc) && floppyImage)
5694	{
5695	/* time to register the image */
5696	CHECK_ERROR(virtualBox, RegisterFloppyImage(floppyImage));
5697	}
5698	}
5699	}
5700	if (!floppyImage)
5701	{
5702	rc = E_FAIL;
5703	break;
5704	}
5705	floppyImage->COMGETTER(Id)(uuid.asOutParam());
5706	CHECK_ERROR(floppyDrive, MountImage(uuid));
5707	}
5708	}
5709	else if (strncmp(argv[1], "-guestmemoryballoon", 19) == 0)
5710	{
5711	if (argc != 3)
5712	{
5713	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5714	rc = E_FAIL;
5715	break;
5716	}
5717	uint32_t uVal;
5718	int vrc;
5719	vrc = RTStrToUInt32Ex(argv[2], NULL, 0, &uVal);
5720	if (vrc != VINF_SUCCESS)
5721	{
5722	errorArgument("Error parsing guest memory balloon size '%s'", argv[2]);
5723	rc = E_FAIL;
5724	break;
5725	}
5726
5727	/* guest is running; update IGuest */
5728	ComPtr <IGuest> guest;
5729
5730	rc = console->COMGETTER(Guest)(guest.asOutParam());
5731	if (SUCCEEDED(rc))
5732	CHECK_ERROR(guest, COMSETTER(MemoryBalloonSize)(uVal));
5733	}
5734	else if (strncmp(argv[1], "-gueststatisticsinterval", 24) == 0)
5735	{
5736	if (argc != 3)
5737	{
5738	errorSyntax(USAGE_CONTROLVM, "Incorrect number of parameters");
5739	rc = E_FAIL;
5740	break;
5741	}
5742	uint32_t uVal;
5743	int vrc;
5744	vrc = RTStrToUInt32Ex(argv[2], NULL, 0, &uVal);
5745	if (vrc != VINF_SUCCESS)
5746	{
5747	errorArgument("Error parsing guest memory balloon size '%s'", argv[2]);
5748	rc = E_FAIL;
5749	break;
5750	}
5751
5752	/* guest is running; update IGuest */
5753	ComPtr <IGuest> guest;
5754
5755	rc = console->COMGETTER(Guest)(guest.asOutParam());
5756	if (SUCCEEDED(rc))
5757	CHECK_ERROR(guest, COMSETTER(StatisticsUpdateInterval)(uVal));
5758	}
5759	else
5760	{
5761	errorSyntax(USAGE_CONTROLVM, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
5762	rc = E_FAIL;
5763	}
5764	}
5765	while (0);
5766
5767	session->Close();
5768
5769	return SUCCEEDED (rc) ? 0 : 1;
5770	}
5771
5772	static int handleDiscardState(int argc, char *argv[],
5773	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
5774	{
5775	HRESULT rc;
5776
5777	if (argc != 1)
5778	{
5779	return errorSyntax(USAGE_DISCARDSTATE, "Incorrect number of parameters");
5780	}
5781
5782	ComPtr<IMachine> machine;
5783	/* assume it's a UUID */
5784	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
5785	if (FAILED(rc) \|\| !machine)
5786	{
5787	/* must be a name */
5788	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
5789	}
5790	if (machine)
5791	{
5792	do
5793	{
5794	/* we have to open a session for this task */
5795	Guid guid;
5796	machine->COMGETTER(Id)(guid.asOutParam());
5797	CHECK_ERROR_BREAK(virtualBox, OpenSession(session, guid));
5798	do
5799	{
5800	ComPtr<IConsole> console;
5801	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
5802	CHECK_ERROR_BREAK(console, DiscardSavedState());
5803	}
5804	while (0);
5805	CHECK_ERROR_BREAK(session, Close());
5806	}
5807	while (0);
5808	}
5809
5810	return SUCCEEDED(rc) ? 0 : 1;
5811	}
5812
5813	static int handleAdoptdState(int argc, char *argv[],
5814	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
5815	{
5816	HRESULT rc;
5817
5818	if (argc != 2)
5819	{
5820	return errorSyntax(USAGE_ADOPTSTATE, "Incorrect number of parameters");
5821	}
5822
5823	ComPtr<IMachine> machine;
5824	/* assume it's a UUID */
5825	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
5826	if (FAILED(rc) \|\| !machine)
5827	{
5828	/* must be a name */
5829	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
5830	}
5831	if (machine)
5832	{
5833	do
5834	{
5835	/* we have to open a session for this task */
5836	Guid guid;
5837	machine->COMGETTER(Id)(guid.asOutParam());
5838	CHECK_ERROR_BREAK(virtualBox, OpenSession(session, guid));
5839	do
5840	{
5841	ComPtr<IConsole> console;
5842	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
5843	CHECK_ERROR_BREAK(console, AdoptSavedState (Bstr (argv[1])));
5844	}
5845	while (0);
5846	CHECK_ERROR_BREAK(session, Close());
5847	}
5848	while (0);
5849	}
5850
5851	return SUCCEEDED(rc) ? 0 : 1;
5852	}
5853
5854	static int handleSnapshot(int argc, char *argv[],
5855	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
5856	{
5857	HRESULT rc;
5858
5859	/* we need at least a VM and a command */
5860	if (argc < 2)
5861	{
5862	return errorSyntax(USAGE_SNAPSHOT, "Not enough parameters");
5863	}
5864
5865	/* the first argument must be the VM */
5866	ComPtr<IMachine> machine;
5867	/* assume it's a UUID */
5868	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
5869	if (FAILED(rc) \|\| !machine)
5870	{
5871	/* must be a name */
5872	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
5873	}
5874	if (!machine)
5875	return 1;
5876	Guid guid;
5877	machine->COMGETTER(Id)(guid.asOutParam());
5878
5879	do
5880	{
5881	/* we have to open a session for this task. First try an existing session */
5882	rc = virtualBox->OpenExistingSession(session, guid);
5883	if (FAILED(rc))
5884	CHECK_ERROR_BREAK(virtualBox, OpenSession(session, guid));
5885	ComPtr<IConsole> console;
5886	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
5887
5888	/* switch based on the command */
5889	if (strcmp(argv[1], "take") == 0)
5890	{
5891	/* there must be a name */
5892	if (argc < 3)
5893	{
5894	errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name");
5895	rc = E_FAIL;
5896	break;
5897	}
5898	Bstr name(argv[2]);
5899	if ((argc > 3) && ((argc != 5) \|\| (strcmp(argv[3], "-desc") != 0)))
5900	{
5901	errorSyntax(USAGE_SNAPSHOT, "Incorrect description format");
5902	rc = E_FAIL;
5903	break;
5904	}
5905	Bstr desc;
5906	if (argc == 5)
5907	desc = argv[4];
5908	ComPtr<IProgress> progress;
5909	CHECK_ERROR_BREAK(console, TakeSnapshot(name, desc, progress.asOutParam()));
5910
5911	showProgress(progress);
5912	progress->COMGETTER(ResultCode)(&rc);
5913	if (FAILED(rc))
5914	{
5915	com::ProgressErrorInfo info(progress);
5916	if (info.isBasicAvailable())
5917	{
5918	RTPrintf("Error: failed to take snapshot. Error message: %lS\n", info.getText().raw());
5919	}
5920	else
5921	{
5922	RTPrintf("Error: failed to take snapshot. No error message available!\n");
5923	}
5924	}
5925	}
5926	else if (strcmp(argv[1], "discard") == 0)
5927	{
5928	/* exactly one parameter: snapshot name */
5929	if (argc != 3)
5930	{
5931	errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only");
5932	rc = E_FAIL;
5933	break;
5934	}
5935
5936	ComPtr<ISnapshot> snapshot;
5937
5938	/* assume it's a UUID */
5939	Guid guid(argv[2]);
5940	if (!guid.isEmpty())
5941	{
5942	CHECK_ERROR_BREAK(machine, GetSnapshot(guid, snapshot.asOutParam()));
5943	}
5944	else
5945	{
5946	/* then it must be a name */
5947	CHECK_ERROR_BREAK(machine, FindSnapshot(Bstr(argv[2]), snapshot.asOutParam()));
5948	}
5949
5950	snapshot->COMGETTER(Id)(guid.asOutParam());
5951
5952	ComPtr<IProgress> progress;
5953	CHECK_ERROR_BREAK(console, DiscardSnapshot(guid, progress.asOutParam()));
5954
5955	showProgress(progress);
5956	progress->COMGETTER(ResultCode)(&rc);
5957	if (FAILED(rc))
5958	{
5959	com::ProgressErrorInfo info(progress);
5960	if (info.isBasicAvailable())
5961	{
5962	RTPrintf("Error: failed to discard snapshot. Error message: %lS\n", info.getText().raw());
5963	}
5964	else
5965	{
5966	RTPrintf("Error: failed to discard snapshot. No error message available!\n");
5967	}
5968	}
5969	}
5970	else if (strcmp(argv[1], "discardcurrent") == 0)
5971	{
5972	if ( (argc != 3)
5973	\|\| ( (strcmp(argv[2], "-state") != 0)
5974	&& (strcmp(argv[2], "-all") != 0)))
5975	{
5976	errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(argv[2]).raw());
5977	rc = E_FAIL;
5978	break;
5979	}
5980	bool fAll = false;
5981	if (strcmp(argv[2], "-all") == 0)
5982	fAll = true;
5983
5984	ComPtr<IProgress> progress;
5985
5986	if (fAll)
5987	{
5988	CHECK_ERROR_BREAK(console, DiscardCurrentSnapshotAndState(progress.asOutParam()));
5989	}
5990	else
5991	{
5992	CHECK_ERROR_BREAK(console, DiscardCurrentState(progress.asOutParam()));
5993	}
5994
5995	showProgress(progress);
5996	progress->COMGETTER(ResultCode)(&rc);
5997	if (FAILED(rc))
5998	{
5999	com::ProgressErrorInfo info(progress);
6000	if (info.isBasicAvailable())
6001	{
6002	RTPrintf("Error: failed to discard. Error message: %lS\n", info.getText().raw());
6003	}
6004	else
6005	{
6006	RTPrintf("Error: failed to discard. No error message available!\n");
6007	}
6008	}
6009
6010	}
6011	else if (strcmp(argv[1], "edit") == 0)
6012	{
6013	if (argc < 3)
6014	{
6015	errorSyntax(USAGE_SNAPSHOT, "Missing snapshot name");
6016	rc = E_FAIL;
6017	break;
6018	}
6019
6020	ComPtr<ISnapshot> snapshot;
6021
6022	if (strcmp(argv[2], "-current") == 0)
6023	{
6024	CHECK_ERROR_BREAK(machine, COMGETTER(CurrentSnapshot)(snapshot.asOutParam()));
6025	}
6026	else
6027	{
6028	/* assume it's a UUID */
6029	Guid guid(argv[2]);
6030	if (!guid.isEmpty())
6031	{
6032	CHECK_ERROR_BREAK(machine, GetSnapshot(guid, snapshot.asOutParam()));
6033	}
6034	else
6035	{
6036	/* then it must be a name */
6037	CHECK_ERROR_BREAK(machine, FindSnapshot(Bstr(argv[2]), snapshot.asOutParam()));
6038	}
6039	}
6040
6041	/* parse options */
6042	for (int i = 3; i < argc; i++)
6043	{
6044	if (strcmp(argv[i], "-newname") == 0)
6045	{
6046	if (argc <= i + 1)
6047	{
6048	errorArgument("Missing argument to '%s'", argv[i]);
6049	rc = E_FAIL;
6050	break;
6051	}
6052	i++;
6053	snapshot->COMSETTER(Name)(Bstr(argv[i]));
6054	}
6055	else if (strcmp(argv[i], "-newdesc") == 0)
6056	{
6057	if (argc <= i + 1)
6058	{
6059	errorArgument("Missing argument to '%s'", argv[i]);
6060	rc = E_FAIL;
6061	break;
6062	}
6063	i++;
6064	snapshot->COMSETTER(Description)(Bstr(argv[i]));
6065	}
6066	else
6067	{
6068	errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
6069	rc = E_FAIL;
6070	break;
6071	}
6072	}
6073
6074	}
6075	else if (strcmp(argv[1], "showvminfo") == 0)
6076	{
6077	/* exactly one parameter: snapshot name */
6078	if (argc != 3)
6079	{
6080	errorSyntax(USAGE_SNAPSHOT, "Expecting snapshot name only");
6081	rc = E_FAIL;
6082	break;
6083	}
6084
6085	ComPtr<ISnapshot> snapshot;
6086
6087	/* assume it's a UUID */
6088	Guid guid(argv[2]);
6089	if (!guid.isEmpty())
6090	{
6091	CHECK_ERROR_BREAK(machine, GetSnapshot(guid, snapshot.asOutParam()));
6092	}
6093	else
6094	{
6095	/* then it must be a name */
6096	CHECK_ERROR_BREAK(machine, FindSnapshot(Bstr(argv[2]), snapshot.asOutParam()));
6097	}
6098
6099	/* get the machine of the given snapshot */
6100	ComPtr<IMachine> machine;
6101	snapshot->COMGETTER(Machine)(machine.asOutParam());
6102	showVMInfo(virtualBox, machine, console);
6103	}
6104	else
6105	{
6106	errorSyntax(USAGE_SNAPSHOT, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
6107	rc = E_FAIL;
6108	}
6109	} while (0);
6110
6111	session->Close();
6112
6113	return SUCCEEDED(rc) ? 0 : 1;
6114	}
6115
6116	static int handleShowVDIInfo(int argc, char *argv[],
6117	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6118	{
6119	HRESULT rc;
6120
6121	if (argc != 1)
6122	{
6123	return errorSyntax(USAGE_SHOWVDIINFO, "Incorrect number of parameters");
6124	}
6125
6126	ComPtr<IHardDisk> hardDisk;
6127	Bstr filepath;
6128
6129	bool registered = true;
6130
6131	/* first guess is that it's a UUID */
6132	Guid uuid(argv[0]);
6133	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
6134	/* no? then it must be a filename */
6135	if (FAILED (rc))
6136	{
6137	filepath = argv[0];
6138	rc = virtualBox->FindHardDisk(filepath, hardDisk.asOutParam());
6139	/* no? well, then it's an unregistered image */
6140	if (FAILED (rc))
6141	{
6142	registered = false;
6143	CHECK_ERROR(virtualBox, OpenHardDisk(filepath, hardDisk.asOutParam()));
6144	}
6145	}
6146	if (SUCCEEDED(rc) && hardDisk)
6147	{
6148	/* query a VDI object (will remain null if it's not VDI) */
6149	ComPtr<IVirtualDiskImage> vdi = hardDisk;
6150
6151	hardDisk->COMGETTER(Id)(uuid.asOutParam());
6152	RTPrintf("UUID: %s\n", uuid.toString().raw());
6153
6154	RTPrintf("Registered: %s\n", registered ? "yes" : "no");
6155
6156	/* check for accessibility */
6157	BOOL accessible = FALSE;
6158	CHECK_ERROR_RET (hardDisk, COMGETTER(Accessible)(&accessible), 1);
6159	RTPrintf("Accessible: %s\n", accessible ? "yes" : "no");
6160
6161	if (!accessible)
6162	{
6163	Bstr err;
6164	CHECK_ERROR_RET (hardDisk, COMGETTER(LastAccessError)(err.asOutParam()), 1);
6165	RTPrintf("Access Error: %lS\n", err.raw());
6166	}
6167
6168	Bstr description;
6169	hardDisk->COMGETTER(Description)(description.asOutParam());
6170	if (description)
6171	{
6172	RTPrintf("Description: %lS\n", description.raw());
6173	}
6174
6175	ULONG64 size;
6176	hardDisk->COMGETTER(Size)(&size);
6177	RTPrintf("Size: %llu MBytes\n", size);
6178	ULONG64 actualSize;
6179	hardDisk->COMGETTER(ActualSize)(&actualSize);
6180	RTPrintf("Current size on disk: %llu MBytes\n", actualSize >> 20);
6181
6182	HardDiskType_T type;
6183	hardDisk->COMGETTER(Type)(&type);
6184	const char *typeStr = "unknown";
6185	switch (type)
6186	{
6187	case HardDiskType_NormalHardDisk:
6188	typeStr = "standard";
6189	break;
6190	case HardDiskType_ImmutableHardDisk:
6191	typeStr = "immutable";
6192	break;
6193	case HardDiskType_WritethroughHardDisk:
6194	typeStr = "writethrough";
6195	break;
6196	}
6197	RTPrintf("Type: %s\n", typeStr);
6198
6199	HardDiskStorageType_T storageType;
6200	const char *storageTypeStr = "unknown";
6201	hardDisk->COMGETTER(StorageType)(&storageType);
6202	switch (storageType)
6203	{
6204	case HardDiskStorageType_VirtualDiskImage:
6205	storageTypeStr = "Virtual Disk Image (VDI)";
6206	break;
6207	case HardDiskStorageType_VMDKImage:
6208	storageTypeStr = "VMDK Image";
6209	break;
6210	case HardDiskStorageType_ISCSIHardDisk:
6211	storageTypeStr = "iSCSI target";
6212	break;
6213	case HardDiskStorageType_VHDImage:
6214	storageTypeStr = "VHD Image";
6215	break;
6216	}
6217	RTPrintf("Storage type: %s\n", storageTypeStr);
6218
6219	if (registered)
6220	{
6221	hardDisk->COMGETTER(MachineId)(uuid.asOutParam());
6222	RTPrintf("In use by VM: %s\n", uuid ? uuid.toString().raw() : "<none>");
6223	}
6224
6225	if (vdi)
6226	{
6227	/* VDI specific information */
6228	vdi->COMGETTER(FilePath)(filepath.asOutParam());
6229	RTPrintf("Path: %lS\n", filepath.raw());
6230
6231	}
6232	else
6233	{
6234	/* Generic location information */
6235	Bstr loc;
6236	hardDisk->COMGETTER(Location)(loc.asOutParam());
6237	RTPrintf("Location: %lS\n", loc.raw());
6238	}
6239	}
6240	return SUCCEEDED(rc) ? 0 : 1;
6241	}
6242
6243	static int handleRegisterImage(int argc, char *argv[],
6244	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6245	{
6246	HRESULT rc;
6247
6248	if (argc < 2)
6249	{
6250	return errorSyntax(USAGE_REGISTERIMAGE, "Not enough parameters");
6251	}
6252
6253	Bstr filepath(argv[1]);
6254
6255	if (strcmp(argv[0], "disk") == 0)
6256	{
6257	const char *type = NULL;
6258	/* there can be a type parameter */
6259	if ((argc > 2) && (argc != 4))
6260	{
6261	return errorSyntax(USAGE_REGISTERIMAGE, "Incorrect number of parameters");
6262	}
6263	if (argc == 4)
6264	{
6265	if (strcmp(argv[2], "-type") != 0)
6266	{
6267	return errorSyntax(USAGE_REGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[2]).raw());
6268	}
6269	if ( (strcmp(argv[3], "normal") != 0)
6270	&& (strcmp(argv[3], "immutable") != 0)
6271	&& (strcmp(argv[3], "writethrough") != 0))
6272	{
6273	return errorArgument("Invalid VDI type '%s' specified", Utf8Str(argv[3]).raw());
6274	}
6275	type = argv[3];
6276	}
6277
6278	ComPtr<IHardDisk> hardDisk;
6279	CHECK_ERROR(virtualBox, OpenHardDisk(filepath, hardDisk.asOutParam()));
6280	if (SUCCEEDED(rc) && hardDisk)
6281	{
6282	/* change the type if requested */
6283	if (type)
6284	{
6285	if (strcmp(type, "normal") == 0)
6286	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_NormalHardDisk));
6287	else if (strcmp(type, "immutable") == 0)
6288	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_ImmutableHardDisk));
6289	else if (strcmp(type, "writethrough") == 0)
6290	CHECK_ERROR(hardDisk, COMSETTER(Type)(HardDiskType_WritethroughHardDisk));
6291	}
6292	if (SUCCEEDED(rc))
6293	CHECK_ERROR(virtualBox, RegisterHardDisk(hardDisk));
6294	}
6295	}
6296	else if (strcmp(argv[0], "dvd") == 0)
6297	{
6298	ComPtr<IDVDImage> dvdImage;
6299	CHECK_ERROR(virtualBox, OpenDVDImage(filepath, Guid(), dvdImage.asOutParam()));
6300	if (SUCCEEDED(rc) && dvdImage)
6301	{
6302	CHECK_ERROR(virtualBox, RegisterDVDImage(dvdImage));
6303	}
6304	}
6305	else if (strcmp(argv[0], "floppy") == 0)
6306	{
6307	ComPtr<IFloppyImage> floppyImage;
6308	CHECK_ERROR(virtualBox, OpenFloppyImage(filepath, Guid(), floppyImage.asOutParam()));
6309	if (SUCCEEDED(rc) && floppyImage)
6310	{
6311	CHECK_ERROR(virtualBox, RegisterFloppyImage(floppyImage));
6312	}
6313	}
6314	else
6315	{
6316	return errorSyntax(USAGE_REGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
6317	}
6318	return SUCCEEDED(rc) ? 0 : 1;
6319	}
6320
6321	static int handleUnregisterImage(int argc, char *argv[],
6322	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6323	{
6324	HRESULT rc;
6325
6326	if (argc != 2)
6327	{
6328	return errorSyntax(USAGE_UNREGISTERIMAGE, "Incorrect number of parameters");
6329	}
6330
6331	/* first guess is that it's a UUID */
6332	Guid uuid(argv[1]);
6333
6334	if (strcmp(argv[0], "disk") == 0)
6335	{
6336	ComPtr<IHardDisk> hardDisk;
6337	rc = virtualBox->GetHardDisk(uuid, hardDisk.asOutParam());
6338	/* not a UUID or not registered? Then it must be a filename */
6339	if (!hardDisk)
6340	{
6341	ComPtr<IVirtualDiskImage> vdi;
6342	CHECK_ERROR(virtualBox, FindVirtualDiskImage(Bstr(argv[1]), vdi.asOutParam()));
6343	hardDisk = vdi;
6344	}
6345	if (SUCCEEDED(rc) && hardDisk)
6346	{
6347	hardDisk->COMGETTER(Id)(uuid.asOutParam());
6348	CHECK_ERROR(virtualBox, UnregisterHardDisk(uuid, hardDisk.asOutParam()));
6349	}
6350	}
6351	else
6352	if (strcmp(argv[0], "dvd") == 0)
6353	{
6354	ComPtr<IDVDImage> dvdImage;
6355	rc = virtualBox->GetDVDImage(uuid, dvdImage.asOutParam());
6356	/* not a UUID or not registered? Then it must be a filename */
6357	if (!dvdImage)
6358	{
6359	ComPtr<IDVDImageCollection> dvdColl;
6360	virtualBox->COMGETTER(DVDImages)(dvdColl.asOutParam());
6361	CHECK_ERROR(dvdColl, FindByPath(Bstr(argv[1]), dvdImage.asOutParam()));
6362	}
6363	if (SUCCEEDED(rc) && dvdImage)
6364	{
6365	dvdImage->COMGETTER(Id)(uuid.asOutParam());
6366	CHECK_ERROR(virtualBox, UnregisterDVDImage(uuid, dvdImage.asOutParam()));
6367	}
6368	}
6369	else
6370	if (strcmp(argv[0], "floppy") == 0)
6371	{
6372	ComPtr<IFloppyImage> floppyImage;
6373	rc = virtualBox->GetFloppyImage(uuid, floppyImage.asOutParam());
6374	/* not a UUID or not registered? Then it must be a filename */
6375	if (!floppyImage)
6376	{
6377	ComPtr<IFloppyImageCollection> floppyColl;
6378	virtualBox->COMGETTER(FloppyImages)(floppyColl.asOutParam());
6379	CHECK_ERROR(floppyColl, FindByPath(Bstr(argv[1]), floppyImage.asOutParam()));
6380	}
6381	if (SUCCEEDED(rc) && floppyImage)
6382	{
6383	floppyImage->COMGETTER(Id)(uuid.asOutParam());
6384	CHECK_ERROR(virtualBox, UnregisterFloppyImage(uuid, floppyImage.asOutParam()));
6385	}
6386	}
6387	else
6388	{
6389	return errorSyntax(USAGE_UNREGISTERIMAGE, "Invalid parameter '%s'", Utf8Str(argv[1]).raw());
6390	}
6391	return SUCCEEDED(rc) ? 0 : 1;
6392	}
6393
6394	#ifdef RT_OS_WINDOWS
6395	static int handleCreateHostIF(int argc, char *argv[],
6396	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6397	{
6398	if (argc != 1)
6399	{
6400	return errorSyntax(USAGE_CREATEHOSTIF, "Incorrect number of parameters");
6401	}
6402
6403	HRESULT rc = S_OK;
6404
6405	do
6406	{
6407	ComPtr<IHost> host;
6408	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
6409
6410	ComPtr<IHostNetworkInterface> hostif;
6411	ComPtr<IProgress> progress;
6412	CHECK_ERROR_BREAK(host,
6413	CreateHostNetworkInterface(Bstr(argv[0]),
6414	hostif.asOutParam(),
6415	progress.asOutParam()));
6416
6417	showProgress(progress);
6418	HRESULT result;
6419	CHECK_ERROR_BREAK(progress, COMGETTER(ResultCode)(&result));
6420	if (FAILED(result))
6421	{
6422	com::ProgressErrorInfo info(progress);
6423	PRINT_ERROR_INFO(info);
6424	rc = result;
6425	}
6426	}
6427	while (0);
6428
6429	return SUCCEEDED(rc) ? 0 : 1;
6430	}
6431
6432	static int handleRemoveHostIF(int argc, char *argv[],
6433	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6434	{
6435	if (argc != 1)
6436	{
6437	return errorSyntax(USAGE_REMOVEHOSTIF, "Incorrect number of parameters");
6438	}
6439
6440	HRESULT rc = S_OK;
6441
6442	do
6443	{
6444	ComPtr<IHost> host;
6445	CHECK_ERROR_BREAK(virtualBox, COMGETTER(Host)(host.asOutParam()));
6446
6447	ComPtr<IHostNetworkInterface> hostif;
6448
6449	/* first guess is that it's a UUID */
6450	Guid uuid(argv[0]);
6451	if (uuid.isEmpty())
6452	{
6453	/* not a valid UUID, search for it */
6454	ComPtr<IHostNetworkInterfaceCollection> coll;
6455	CHECK_ERROR_BREAK(host, COMGETTER(NetworkInterfaces)(coll.asOutParam()));
6456	CHECK_ERROR_BREAK(coll, FindByName(Bstr(argv[0]), hostif.asOutParam()));
6457	CHECK_ERROR_BREAK(hostif, COMGETTER(Id)(uuid.asOutParam()));
6458	}
6459
6460	ComPtr<IProgress> progress;
6461	CHECK_ERROR_BREAK(host,
6462	RemoveHostNetworkInterface(uuid,
6463	hostif.asOutParam(),
6464	progress.asOutParam()));
6465
6466	showProgress(progress);
6467	HRESULT result;
6468	CHECK_ERROR_BREAK(progress, COMGETTER(ResultCode)(&result));
6469	if (FAILED(result))
6470	{
6471	com::ProgressErrorInfo info(progress);
6472	PRINT_ERROR_INFO(info);
6473	rc = result;
6474	}
6475	}
6476	while (0);
6477
6478	return SUCCEEDED(rc) ? 0 : 1;
6479	}
6480	#endif /* RT_OS_WINDOWS */
6481
6482	static int handleGetExtraData(int argc, char *argv[],
6483	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6484	{
6485	HRESULT rc = S_OK;
6486
6487	if (argc != 2)
6488	{
6489	return errorSyntax(USAGE_GETEXTRADATA, "Incorrect number of parameters");
6490	}
6491	/* global data? */
6492	if (strcmp(argv[0], "global") == 0)
6493	{
6494	/* enumeration? */
6495	if (strcmp(argv[1], "enumerate") == 0)
6496	{
6497	Bstr extraDataKey;
6498
6499	do
6500	{
6501	Bstr nextExtraDataKey;
6502	Bstr nextExtraDataValue;
6503	HRESULT rcEnum = virtualBox->GetNextExtraDataKey(extraDataKey, nextExtraDataKey.asOutParam(),
6504	nextExtraDataValue.asOutParam());
6505	extraDataKey = nextExtraDataKey;
6506
6507	if (SUCCEEDED(rcEnum) && extraDataKey)
6508	{
6509	RTPrintf("Key: %lS, Value: %lS\n", nextExtraDataKey.raw(), nextExtraDataValue.raw());
6510	}
6511	} while (extraDataKey);
6512	}
6513	else
6514	{
6515	Bstr value;
6516	CHECK_ERROR(virtualBox, GetExtraData(Bstr(argv[1]), value.asOutParam()));
6517	if (value)
6518	RTPrintf("Value: %lS\n", value.raw());
6519	else
6520	RTPrintf("No value set!\n");
6521	}
6522	}
6523	else
6524	{
6525	ComPtr<IMachine> machine;
6526	/* assume it's a UUID */
6527	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
6528	if (FAILED(rc) \|\| !machine)
6529	{
6530	/* must be a name */
6531	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
6532	}
6533	if (machine)
6534	{
6535	/* enumeration? */
6536	if (strcmp(argv[1], "enumerate") == 0)
6537	{
6538	Bstr extraDataKey;
6539
6540	do
6541	{
6542	Bstr nextExtraDataKey;
6543	Bstr nextExtraDataValue;
6544	HRESULT rcEnum = machine->GetNextExtraDataKey(extraDataKey, nextExtraDataKey.asOutParam(),
6545	nextExtraDataValue.asOutParam());
6546	extraDataKey = nextExtraDataKey;
6547
6548	if (SUCCEEDED(rcEnum) && extraDataKey)
6549	{
6550	RTPrintf("Key: %lS, Value: %lS\n", nextExtraDataKey.raw(), nextExtraDataValue.raw());
6551	}
6552	} while (extraDataKey);
6553	}
6554	else
6555	{
6556	Bstr value;
6557	CHECK_ERROR(machine, GetExtraData(Bstr(argv[1]), value.asOutParam()));
6558	if (value)
6559	RTPrintf("Value: %lS\n", value.raw());
6560	else
6561	RTPrintf("No value set!\n");
6562	}
6563	}
6564	}
6565	return SUCCEEDED(rc) ? 0 : 1;
6566	}
6567
6568	static int handleSetExtraData(int argc, char *argv[],
6569	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6570	{
6571	HRESULT rc = S_OK;
6572
6573	if (argc < 2)
6574	{
6575	return errorSyntax(USAGE_SETEXTRADATA, "Not enough parameters");
6576	}
6577	/* global data? */
6578	if (strcmp(argv[0], "global") == 0)
6579	{
6580	if (argc < 3)
6581	CHECK_ERROR(virtualBox, SetExtraData(Bstr(argv[1]), NULL));
6582	else if (argc == 3)
6583	CHECK_ERROR(virtualBox, SetExtraData(Bstr(argv[1]), Bstr(argv[2])));
6584	else
6585	return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
6586	}
6587	else
6588	{
6589	ComPtr<IMachine> machine;
6590	/* assume it's a UUID */
6591	rc = virtualBox->GetMachine(Guid(argv[0]), machine.asOutParam());
6592	if (FAILED(rc) \|\| !machine)
6593	{
6594	/* must be a name */
6595	CHECK_ERROR(virtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
6596	}
6597	if (machine)
6598	{
6599	if (argc < 3)
6600	CHECK_ERROR(machine, SetExtraData(Bstr(argv[1]), NULL));
6601	else if (argc == 3)
6602	CHECK_ERROR(machine, SetExtraData(Bstr(argv[1]), Bstr(argv[2])));
6603	else
6604	return errorSyntax(USAGE_SETEXTRADATA, "Too many parameters");
6605	}
6606	}
6607	return SUCCEEDED(rc) ? 0 : 1;
6608	}
6609
6610	static int handleSetProperty(int argc, char *argv[],
6611	ComPtr<IVirtualBox> virtualBox, ComPtr<ISession> session)
6612	{
6613	HRESULT rc;
6614
6615	/* there must be two arguments: property name and value */
6616	if (argc != 2)
6617	{
6618	return errorSyntax(USAGE_SETPROPERTY, "Incorrect number of parameters");
6619	}
6620	ComPtr<ISystemProperties> systemProperties;
6621	virtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
6622
6623	if (strcmp(argv[0], "vdifolder") == 0)
6624	{
6625	/* reset to default? */
6626	if (strcmp(argv[1], "default") == 0)
6627	CHECK_ERROR(systemProperties, COMSETTER(DefaultVDIFolder)(NULL));
6628	else
6629	CHECK_ERROR(systemProperties, COMSETTER(DefaultVDIFolder)(Bstr(argv[1])));
6630	}
6631	else if (strcmp(argv[0], "machinefolder") == 0)
6632	{
6633	/* reset to default? */
6634	if (strcmp(argv[1], "default") == 0)
6635	CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(NULL));
6636	else
6637	CHECK_ERROR(systemProperties, COMSETTER(DefaultMachineFolder)(Bstr(argv[1])));
6638	}
6639	else if (strcmp(argv[0], "vrdpauthlibrary") == 0)
6640	{
6641	/* reset to default? */
6642	if (strcmp(argv[1], "default") == 0)
6643	CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(NULL));
6644	else
6645	CHECK_ERROR(systemProperties, COMSETTER(RemoteDisplayAuthLibrary)(Bstr(argv[1])));
6646	}
6647	else if (strcmp(argv[0], "websrvauthlibrary") == 0)
6648	{
6649	/* reset to default? */
6650	if (strcmp(argv[1], "default") == 0)
6651	CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(NULL));
6652	else
6653	CHECK_ERROR(systemProperties, COMSETTER(WebServiceAuthLibrary)(Bstr(argv[1])));
6654	}
6655	else if (strcmp(argv[0], "hwvirtexenabled") == 0)
6656	{
6657	if (strcmp(argv[1], "yes") == 0)
6658	CHECK_ERROR(systemProperties, COMSETTER(HWVirtExEnabled)(TRUE));
6659	else if (strcmp(argv[1], "no") == 0)
6660	CHECK_ERROR(systemProperties, COMSETTER(HWVirtExEnabled)(FALSE));
6661	else
6662	return errorArgument("Invalid value '%s' for hardware virtualization extension flag", argv[1]);
6663	}
6664	else if (strcmp(argv[0], "loghistorycount") == 0)
6665	{
6666	uint32_t uVal;
6667	int vrc;
6668	vrc = RTStrToUInt32Ex(argv[1], NULL, 0, &uVal);
6669	if (vrc != VINF_SUCCESS)
6670	return errorArgument("Error parsing Log history count '%s'", argv[1]);
6671	CHECK_ERROR(systemProperties, COMSETTER(LogHistoryCount)(uVal));
6672	}
6673	else
6674	return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", argv[0]);
6675
6676	return SUCCEEDED(rc) ? 0 : 1;
6677	}
6678
6679	static int handleUSBFilter (int argc, char *argv[],
6680	ComPtr <IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
6681	{
6682	HRESULT rc = S_OK;
6683	USBFilterCmd cmd;
6684
6685	/* at least: 0: command, 1: index, 2: -target, 3: <target value> */
6686	if (argc < 4)
6687	{
6688	return errorSyntax(USAGE_USBFILTER, "Not enough parameters");
6689	}
6690
6691	/* which command? */
6692	cmd.mAction = USBFilterCmd::Invalid;
6693	if (strcmp (argv [0], "add") == 0) cmd.mAction = USBFilterCmd::Add;
6694	else if (strcmp (argv [0], "modify") == 0) cmd.mAction = USBFilterCmd::Modify;
6695	else if (strcmp (argv [0], "remove") == 0) cmd.mAction = USBFilterCmd::Remove;
6696
6697	if (cmd.mAction == USBFilterCmd::Invalid)
6698	{
6699	return errorSyntax(USAGE_USBFILTER, "Invalid parameter '%s'", argv[0]);
6700	}
6701
6702	/* which index? */
6703	char *endptr = NULL;
6704	cmd.mIndex = strtoul (argv[1], &endptr, 10);
6705	if (!endptr \|\| *endptr)
6706	{
6707	return errorSyntax(USAGE_USBFILTER, "Invalid index '%s'", argv[1]);
6708	}
6709
6710	switch (cmd.mAction)
6711	{
6712	case USBFilterCmd::Add:
6713	case USBFilterCmd::Modify:
6714	{
6715	/* at least: 0: command, 1: index, 2: -target, 3: <target value>, 4: -name, 5: <name value> */
6716	if (argc < 6)
6717	{
6718	if (cmd.mAction == USBFilterCmd::Add)
6719	{
6720	return errorSyntax(USAGE_USBFILTER_ADD, "Not enough parameters");
6721	}
6722	return errorSyntax(USAGE_USBFILTER_MODIFY, "Not enough parameters");
6723	}
6724
6725	// set Active to true by default
6726	// (assuming that the user sets up all necessary attributes
6727	// at once and wants the filter to be active immediately)
6728	if (cmd.mAction == USBFilterCmd::Add)
6729	cmd.mFilter.mActive = true;
6730
6731	for (int i = 2; i < argc; i++)
6732	{
6733	if (strcmp(argv [i], "-target") == 0)
6734	{
6735	if (argc <= i + 1 \|\| !*argv[i+1])
6736	{
6737	return errorArgument("Missing argument to '%s'", argv[i]);
6738	}
6739	i++;
6740	if (strcmp (argv [i], "global") == 0)
6741	cmd.mGlobal = true;
6742	else
6743	{
6744	/* assume it's a UUID of a machine */
6745	rc = aVirtualBox->GetMachine(Guid(argv[i]), cmd.mMachine.asOutParam());
6746	if (FAILED(rc) \|\| !cmd.mMachine)
6747	{
6748	/* must be a name */
6749	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[i]), cmd.mMachine.asOutParam()), 1);
6750	}
6751	}
6752	}
6753	else if (strcmp(argv [i], "-name") == 0)
6754	{
6755	if (argc <= i + 1 \|\| !*argv[i+1])
6756	{
6757	return errorArgument("Missing argument to '%s'", argv[i]);
6758	}
6759	i++;
6760	cmd.mFilter.mName = argv [i];
6761	}
6762	else if (strcmp(argv [i], "-active") == 0)
6763	{
6764	if (argc <= i + 1)
6765	{
6766	return errorArgument("Missing argument to '%s'", argv[i]);
6767	}
6768	i++;
6769	if (strcmp (argv [i], "yes") == 0)
6770	cmd.mFilter.mActive = true;
6771	else if (strcmp (argv [i], "no") == 0)
6772	cmd.mFilter.mActive = false;
6773	else
6774	{
6775	return errorArgument("Invalid -active argument '%s'", argv[i]);
6776	}
6777	}
6778	else if (strcmp(argv [i], "-vendorid") == 0)
6779	{
6780	if (argc <= i + 1)
6781	{
6782	return errorArgument("Missing argument to '%s'", argv[i]);
6783	}
6784	i++;
6785	cmd.mFilter.mVendorId = argv [i];
6786	}
6787	else if (strcmp(argv [i], "-productid") == 0)
6788	{
6789	if (argc <= i + 1)
6790	{
6791	return errorArgument("Missing argument to '%s'", argv[i]);
6792	}
6793	i++;
6794	cmd.mFilter.mProductId = argv [i];
6795	}
6796	else if (strcmp(argv [i], "-revision") == 0)
6797	{
6798	if (argc <= i + 1)
6799	{
6800	return errorArgument("Missing argument to '%s'", argv[i]);
6801	}
6802	i++;
6803	cmd.mFilter.mRevision = argv [i];
6804	}
6805	else if (strcmp(argv [i], "-manufacturer") == 0)
6806	{
6807	if (argc <= i + 1)
6808	{
6809	return errorArgument("Missing argument to '%s'", argv[i]);
6810	}
6811	i++;
6812	cmd.mFilter.mManufacturer = argv [i];
6813	}
6814	else if (strcmp(argv [i], "-product") == 0)
6815	{
6816	if (argc <= i + 1)
6817	{
6818	return errorArgument("Missing argument to '%s'", argv[i]);
6819	}
6820	i++;
6821	cmd.mFilter.mProduct = argv [i];
6822	}
6823	else if (strcmp(argv [i], "-remote") == 0)
6824	{
6825	if (argc <= i + 1)
6826	{
6827	return errorArgument("Missing argument to '%s'", argv[i]);
6828	}
6829	i++;
6830	cmd.mFilter.mRemote = argv[i];
6831	}
6832	else if (strcmp(argv [i], "-serialnumber") == 0)
6833	{
6834	if (argc <= i + 1)
6835	{
6836	return errorArgument("Missing argument to '%s'", argv[i]);
6837	}
6838	i++;
6839	cmd.mFilter.mSerialNumber = argv [i];
6840	}
6841	else if (strcmp(argv [i], "-maskedinterfaces") == 0)
6842	{
6843	if (argc <= i + 1)
6844	{
6845	return errorArgument("Missing argument to '%s'", argv[i]);
6846	}
6847	i++;
6848	uint32_t u32;
6849	rc = RTStrToUInt32Full(argv[i], 0, &u32);
6850	if (RT_FAILURE(rc))
6851	{
6852	return errorArgument("Failed to convert the -maskedinterfaces value '%s' to a number, rc=%Rrc", argv[i], rc);
6853	}
6854	cmd.mFilter.mMaskedInterfaces = u32;
6855	}
6856	else if (strcmp(argv [i], "-action") == 0)
6857	{
6858	if (argc <= i + 1)
6859	{
6860	return errorArgument("Missing argument to '%s'", argv[i]);
6861	}
6862	i++;
6863	if (strcmp (argv [i], "ignore") == 0)
6864	cmd.mFilter.mAction = USBDeviceFilterAction_USBDeviceFilterIgnore;
6865	else if (strcmp (argv [i], "hold") == 0)
6866	cmd.mFilter.mAction = USBDeviceFilterAction_USBDeviceFilterHold;
6867	else
6868	{
6869	return errorArgument("Invalid USB filter action '%s'", argv[i]);
6870	}
6871	}
6872	else
6873	{
6874	return errorSyntax(cmd.mAction == USBFilterCmd::Add ? USAGE_USBFILTER_ADD : USAGE_USBFILTER_MODIFY,
6875	"Unknown option '%s'", argv[i]);
6876	}
6877	}
6878
6879	if (cmd.mAction == USBFilterCmd::Add)
6880	{
6881	// mandatory/forbidden options
6882	if ( cmd.mFilter.mName.isEmpty()
6883	\|\|
6884	( cmd.mGlobal
6885	&& cmd.mFilter.mAction == USBDeviceFilterAction_InvalidUSBDeviceFilterAction
6886	)
6887	\|\| ( !cmd.mGlobal
6888	&& !cmd.mMachine)
6889	\|\| ( cmd.mGlobal
6890	&& cmd.mFilter.mRemote)
6891	)
6892	{
6893	return errorSyntax(USAGE_USBFILTER_ADD, "Mandatory options not supplied");
6894	}
6895	}
6896	break;
6897	}
6898
6899	case USBFilterCmd::Remove:
6900	{
6901	/* at least: 0: command, 1: index, 2: -target, 3: <target value> */
6902	if (argc < 4)
6903	{
6904	return errorSyntax(USAGE_USBFILTER_REMOVE, "Not enough parameters");
6905	}
6906
6907	for (int i = 2; i < argc; i++)
6908	{
6909	if (strcmp(argv [i], "-target") == 0)
6910	{
6911	if (argc <= i + 1 \|\| !*argv[i+1])
6912	{
6913	return errorArgument("Missing argument to '%s'", argv[i]);
6914	}
6915	i++;
6916	if (strcmp (argv [i], "global") == 0)
6917	cmd.mGlobal = true;
6918	else
6919	{
6920	/* assume it's a UUID of a machine */
6921	rc = aVirtualBox->GetMachine(Guid(argv[i]), cmd.mMachine.asOutParam());
6922	if (FAILED(rc) \|\| !cmd.mMachine)
6923	{
6924	/* must be a name */
6925	CHECK_ERROR_RET(aVirtualBox, FindMachine(Bstr(argv[i]), cmd.mMachine.asOutParam()), 1);
6926	}
6927	}
6928	}
6929	}
6930
6931	// mandatory options
6932	if (!cmd.mGlobal && !cmd.mMachine)
6933	{
6934	return errorSyntax(USAGE_USBFILTER_REMOVE, "Mandatory options not supplied");
6935	}
6936
6937	break;
6938	}
6939
6940	default: break;
6941	}
6942
6943	USBFilterCmd::USBFilter &f = cmd.mFilter;
6944
6945	ComPtr <IHost> host;
6946	ComPtr <IUSBController> ctl;
6947	if (cmd.mGlobal)
6948	CHECK_ERROR_RET (aVirtualBox, COMGETTER(Host) (host.asOutParam()), 1);
6949	else
6950	{
6951	Guid uuid;
6952	cmd.mMachine->COMGETTER(Id)(uuid.asOutParam());
6953	/* open a session for the VM */
6954	CHECK_ERROR_RET (aVirtualBox, OpenSession(aSession, uuid), 1);
6955	/* get the mutable session machine */
6956	aSession->COMGETTER(Machine)(cmd.mMachine.asOutParam());
6957	/* and get the USB controller */
6958	CHECK_ERROR_RET (cmd.mMachine, COMGETTER(USBController) (ctl.asOutParam()), 1);
6959	}
6960
6961	switch (cmd.mAction)
6962	{
6963	case USBFilterCmd::Add:
6964	{
6965	if (cmd.mGlobal)
6966	{
6967	ComPtr <IHostUSBDeviceFilter> flt;
6968	CHECK_ERROR_BREAK (host, CreateUSBDeviceFilter (f.mName, flt.asOutParam()));
6969
6970	if (!f.mActive.isNull())
6971	CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
6972	if (!f.mVendorId.isNull())
6973	CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId.setNullIfEmpty()));
6974	if (!f.mProductId.isNull())
6975	CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId.setNullIfEmpty()));
6976	if (!f.mRevision.isNull())
6977	CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision.setNullIfEmpty()));
6978	if (!f.mManufacturer.isNull())
6979	CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer.setNullIfEmpty()));
6980	if (!f.mSerialNumber.isNull())
6981	CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber.setNullIfEmpty()));
6982	if (!f.mMaskedInterfaces.isNull())
6983	CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
6984
6985	if (f.mAction != USBDeviceFilterAction_InvalidUSBDeviceFilterAction)
6986	CHECK_ERROR_BREAK (flt, COMSETTER(Action) (f.mAction));
6987
6988	CHECK_ERROR_BREAK (host, InsertUSBDeviceFilter (cmd.mIndex, flt));
6989	}
6990	else
6991	{
6992	ComPtr <IUSBDeviceFilter> flt;
6993	CHECK_ERROR_BREAK (ctl, CreateDeviceFilter (f.mName, flt.asOutParam()));
6994
6995	if (!f.mActive.isNull())
6996	CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
6997	if (!f.mVendorId.isNull())
6998	CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId.setNullIfEmpty()));
6999	if (!f.mProductId.isNull())
7000	CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId.setNullIfEmpty()));
7001	if (!f.mRevision.isNull())
7002	CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision.setNullIfEmpty()));
7003	if (!f.mManufacturer.isNull())
7004	CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer.setNullIfEmpty()));
7005	if (!f.mRemote.isNull())
7006	CHECK_ERROR_BREAK (flt, COMSETTER(Remote) (f.mRemote.setNullIfEmpty()));
7007	if (!f.mSerialNumber.isNull())
7008	CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber.setNullIfEmpty()));
7009	if (!f.mMaskedInterfaces.isNull())
7010	CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
7011
7012	CHECK_ERROR_BREAK (ctl, InsertDeviceFilter (cmd.mIndex, flt));
7013	}
7014	break;
7015	}
7016	case USBFilterCmd::Modify:
7017	{
7018	if (cmd.mGlobal)
7019	{
7020	ComPtr <IHostUSBDeviceFilterCollection> coll;
7021	CHECK_ERROR_BREAK (host, COMGETTER(USBDeviceFilters) (coll.asOutParam()));
7022	ComPtr <IHostUSBDeviceFilter> flt;
7023	CHECK_ERROR_BREAK (coll, GetItemAt (cmd.mIndex, flt.asOutParam()));
7024
7025	if (!f.mName.isNull())
7026	CHECK_ERROR_BREAK (flt, COMSETTER(Name) (f.mName.setNullIfEmpty()));
7027	if (!f.mActive.isNull())
7028	CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
7029	if (!f.mVendorId.isNull())
7030	CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId.setNullIfEmpty()));
7031	if (!f.mProductId.isNull())
7032	CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId.setNullIfEmpty()));
7033	if (!f.mRevision.isNull())
7034	CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision.setNullIfEmpty()));
7035	if (!f.mManufacturer.isNull())
7036	CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer.setNullIfEmpty()));
7037	if (!f.mSerialNumber.isNull())
7038	CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber.setNullIfEmpty()));
7039	if (!f.mMaskedInterfaces.isNull())
7040	CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
7041
7042	if (f.mAction != USBDeviceFilterAction_InvalidUSBDeviceFilterAction)
7043	CHECK_ERROR_BREAK (flt, COMSETTER(Action) (f.mAction));
7044	}
7045	else
7046	{
7047	ComPtr <IUSBDeviceFilterCollection> coll;
7048	CHECK_ERROR_BREAK (ctl, COMGETTER(DeviceFilters) (coll.asOutParam()));
7049
7050	ComPtr <IUSBDeviceFilter> flt;
7051	CHECK_ERROR_BREAK (coll, GetItemAt (cmd.mIndex, flt.asOutParam()));
7052
7053	if (!f.mName.isNull())
7054	CHECK_ERROR_BREAK (flt, COMSETTER(Name) (f.mName.setNullIfEmpty()));
7055	if (!f.mActive.isNull())
7056	CHECK_ERROR_BREAK (flt, COMSETTER(Active) (f.mActive));
7057	if (!f.mVendorId.isNull())
7058	CHECK_ERROR_BREAK (flt, COMSETTER(VendorId) (f.mVendorId.setNullIfEmpty()));
7059	if (!f.mProductId.isNull())
7060	CHECK_ERROR_BREAK (flt, COMSETTER(ProductId) (f.mProductId.setNullIfEmpty()));
7061	if (!f.mRevision.isNull())
7062	CHECK_ERROR_BREAK (flt, COMSETTER(Revision) (f.mRevision.setNullIfEmpty()));
7063	if (!f.mManufacturer.isNull())
7064	CHECK_ERROR_BREAK (flt, COMSETTER(Manufacturer) (f.mManufacturer.setNullIfEmpty()));
7065	if (!f.mRemote.isNull())
7066	CHECK_ERROR_BREAK (flt, COMSETTER(Remote) (f.mRemote.setNullIfEmpty()));
7067	if (!f.mSerialNumber.isNull())
7068	CHECK_ERROR_BREAK (flt, COMSETTER(SerialNumber) (f.mSerialNumber.setNullIfEmpty()));
7069	if (!f.mMaskedInterfaces.isNull())
7070	CHECK_ERROR_BREAK (flt, COMSETTER(MaskedInterfaces) (f.mMaskedInterfaces));
7071	}
7072	break;
7073	}
7074	case USBFilterCmd::Remove:
7075	{
7076	if (cmd.mGlobal)
7077	{
7078	ComPtr <IHostUSBDeviceFilter> flt;
7079	CHECK_ERROR_BREAK (host, RemoveUSBDeviceFilter (cmd.mIndex, flt.asOutParam()));
7080	}
7081	else
7082	{
7083	ComPtr <IUSBDeviceFilter> flt;
7084	CHECK_ERROR_BREAK (ctl, RemoveDeviceFilter (cmd.mIndex, flt.asOutParam()));
7085	}
7086	break;
7087	}
7088	default:
7089	break;
7090	}
7091
7092	if (cmd.mMachine)
7093	{
7094	/* commit and close the session */
7095	CHECK_ERROR(cmd.mMachine, SaveSettings());
7096	aSession->Close();
7097	}
7098
7099	return SUCCEEDED (rc) ? 0 : 1;
7100	}
7101
7102	static int handleSharedFolder (int argc, char *argv[],
7103	ComPtr <IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
7104	{
7105	HRESULT rc;
7106
7107	/* we need at least a command and target */
7108	if (argc < 2)
7109	{
7110	return errorSyntax(USAGE_SHAREDFOLDER, "Not enough parameters");
7111	}
7112
7113	ComPtr<IMachine> machine;
7114	/* assume it's a UUID */
7115	rc = aVirtualBox->GetMachine(Guid(argv[1]), machine.asOutParam());
7116	if (FAILED(rc) \|\| !machine)
7117	{
7118	/* must be a name */
7119	CHECK_ERROR(aVirtualBox, FindMachine(Bstr(argv[1]), machine.asOutParam()));
7120	}
7121	if (!machine)
7122	return 1;
7123	Guid uuid;
7124	machine->COMGETTER(Id)(uuid.asOutParam());
7125
7126	if (strcmp(argv[0], "add") == 0)
7127	{
7128	/* we need at least four more parameters */
7129	if (argc < 5)
7130	{
7131	return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Not enough parameters");
7132	}
7133
7134	char *name = NULL;
7135	char *hostpath = NULL;
7136	bool fTransient = false;
7137	bool fWritable = true;
7138
7139	for (int i = 2; i < argc; i++)
7140	{
7141	if (strcmp(argv[i], "-name") == 0)
7142	{
7143	if (argc <= i + 1 \|\| !*argv[i+1])
7144	{
7145	return errorArgument("Missing argument to '%s'", argv[i]);
7146	}
7147	i++;
7148	name = argv[i];
7149	}
7150	else if (strcmp(argv[i], "-hostpath") == 0)
7151	{
7152	if (argc <= i + 1 \|\| !*argv[i+1])
7153	{
7154	return errorArgument("Missing argument to '%s'", argv[i]);
7155	}
7156	i++;
7157	hostpath = argv[i];
7158	}
7159	else if (strcmp(argv[i], "-readonly") == 0)
7160	{
7161	fWritable = false;
7162	}
7163	else if (strcmp(argv[i], "-transient") == 0)
7164	{
7165	fTransient = true;
7166	}
7167	else
7168	{
7169	return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
7170	}
7171	}
7172
7173	/* required arguments */
7174	if (!name \|\| !hostpath)
7175	{
7176	return errorSyntax(USAGE_SHAREDFOLDER_ADD, "Parameters -name and -hostpath are required");
7177	}
7178
7179	if (fTransient)
7180	{
7181	ComPtr <IConsole> console;
7182
7183	/* open an existing session for the VM */
7184	CHECK_ERROR_RET(aVirtualBox, OpenExistingSession (aSession, uuid), 1);
7185	/* get the session machine */
7186	CHECK_ERROR_RET(aSession, COMGETTER(Machine)(machine.asOutParam()), 1);
7187	/* get the session console */
7188	CHECK_ERROR_RET(aSession, COMGETTER(Console)(console.asOutParam()), 1);
7189
7190	CHECK_ERROR(console, CreateSharedFolder(Bstr(name), Bstr(hostpath), fWritable));
7191
7192	if (console)
7193	aSession->Close();
7194	}
7195	else
7196	{
7197	/* open a session for the VM */
7198	CHECK_ERROR_RET (aVirtualBox, OpenSession(aSession, uuid), 1);
7199
7200	/* get the mutable session machine */
7201	aSession->COMGETTER(Machine)(machine.asOutParam());
7202
7203	CHECK_ERROR(machine, CreateSharedFolder(Bstr(name), Bstr(hostpath), fWritable));
7204
7205	if (SUCCEEDED(rc))
7206	CHECK_ERROR(machine, SaveSettings());
7207
7208	aSession->Close();
7209	}
7210	}
7211	else if (strcmp(argv[0], "remove") == 0)
7212	{
7213	/* we need at least two more parameters */
7214	if (argc < 3)
7215	{
7216	return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Not enough parameters");
7217	}
7218
7219	char *name = NULL;
7220	bool fTransient = false;
7221
7222	for (int i = 2; i < argc; i++)
7223	{
7224	if (strcmp(argv[i], "-name") == 0)
7225	{
7226	if (argc <= i + 1 \|\| !*argv[i+1])
7227	{
7228	return errorArgument("Missing argument to '%s'", argv[i]);
7229	}
7230	i++;
7231	name = argv[i];
7232	}
7233	else if (strcmp(argv[i], "-transient") == 0)
7234	{
7235	fTransient = true;
7236	}
7237	else
7238	{
7239	return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
7240	}
7241	}
7242
7243	/* required arguments */
7244	if (!name)
7245	{
7246	return errorSyntax(USAGE_SHAREDFOLDER_REMOVE, "Parameter -name is required");
7247	}
7248
7249	if (fTransient)
7250	{
7251	ComPtr <IConsole> console;
7252
7253	/* open an existing session for the VM */
7254	CHECK_ERROR_RET(aVirtualBox, OpenExistingSession (aSession, uuid), 1);
7255	/* get the session machine */
7256	CHECK_ERROR_RET(aSession, COMGETTER(Machine)(machine.asOutParam()), 1);
7257	/* get the session console */
7258	CHECK_ERROR_RET(aSession, COMGETTER(Console)(console.asOutParam()), 1);
7259
7260	CHECK_ERROR(console, RemoveSharedFolder(Bstr(name)));
7261
7262	if (console)
7263	aSession->Close();
7264	}
7265	else
7266	{
7267	/* open a session for the VM */
7268	CHECK_ERROR_RET (aVirtualBox, OpenSession(aSession, uuid), 1);
7269
7270	/* get the mutable session machine */
7271	aSession->COMGETTER(Machine)(machine.asOutParam());
7272
7273	CHECK_ERROR(machine, RemoveSharedFolder(Bstr(name)));
7274
7275	/* commit and close the session */
7276	CHECK_ERROR(machine, SaveSettings());
7277	aSession->Close();
7278	}
7279	}
7280	else
7281	{
7282	return errorSyntax(USAGE_SETPROPERTY, "Invalid parameter '%s'", Utf8Str(argv[0]).raw());
7283	}
7284	return 0;
7285	}
7286
7287	static int handleVMStatistics(int argc, char *argv[],
7288	ComPtr<IVirtualBox> aVirtualBox, ComPtr<ISession> aSession)
7289	{
7290	HRESULT rc;
7291
7292	/* at least one option: the UUID or name of the VM */
7293	if (argc < 1)
7294	return errorSyntax(USAGE_VM_STATISTICS, "Incorrect number of parameters");
7295
7296	/* try to find the given machine */
7297	ComPtr <IMachine> machine;
7298	Guid uuid (argv[0]);
7299	if (!uuid.isEmpty())
7300	CHECK_ERROR(aVirtualBox, GetMachine(uuid, machine.asOutParam()));
7301	else
7302	{
7303	CHECK_ERROR(aVirtualBox, FindMachine(Bstr(argv[0]), machine.asOutParam()));
7304	if (SUCCEEDED (rc))
7305	machine->COMGETTER(Id)(uuid.asOutParam());
7306	}
7307	if (FAILED(rc))
7308	return 1;
7309
7310	/* parse arguments. */
7311	bool fReset = false;
7312	bool fWithDescriptions = false;
7313	const char pszPattern = NULL; / all */
7314	for (int i = 1; i < argc; i++)
7315	{
7316	if (!strcmp(argv[i], "-pattern"))
7317	{
7318	if (pszPattern)
7319	return errorSyntax(USAGE_VM_STATISTICS, "Multiple -patterns options is not permitted");
7320	if (i + 1 >= argc)
7321	return errorArgument("Missing argument to '%s'", argv[i]);
7322	pszPattern = argv[++i];
7323	}
7324	else if (!strcmp(argv[i], "-descriptions"))
7325	fWithDescriptions = true;
7326	/* add: -file <filename> and -formatted */
7327	else if (!strcmp(argv[i], "-reset"))
7328	fReset = true;
7329	else
7330	return errorSyntax(USAGE_VM_STATISTICS, "Unknown option '%s'", argv[i]);
7331	}
7332	if (fReset && fWithDescriptions)
7333	return errorSyntax(USAGE_VM_STATISTICS, "The -reset and -descriptions options does not mix");
7334
7335
7336	/* open an existing session for the VM. */
7337	CHECK_ERROR(aVirtualBox, OpenExistingSession(aSession, uuid));
7338	if (SUCCEEDED(rc))
7339	{
7340	/* get the session console. */
7341	ComPtr <IConsole> console;
7342	CHECK_ERROR(aSession, COMGETTER(Console)(console.asOutParam()));
7343	if (SUCCEEDED(rc))
7344	{
7345	/* get the machine debugger. */
7346	ComPtr <IMachineDebugger> debugger;
7347	CHECK_ERROR(console, COMGETTER(Debugger)(debugger.asOutParam()));
7348	if (SUCCEEDED(rc))
7349	{
7350	if (fReset)
7351	CHECK_ERROR(debugger, ResetStats(Bstr(pszPattern).raw()));
7352	else
7353	{
7354	Bstr stats;
7355	CHECK_ERROR(debugger, GetStats(Bstr(pszPattern).raw(), fWithDescriptions, stats.asOutParam()));
7356	if (SUCCEEDED(rc))
7357	{
7358	/* if (fFormatted)
7359	{ big mess }
7360	else
7361	*/
7362	RTPrintf("%ls\n", stats.raw());
7363	}
7364	}
7365	}
7366	aSession->Close();
7367	}
7368	}
7369
7370	return SUCCEEDED(rc) ? 0 : 1;
7371	}
7372
7373	enum HUSPD { HUSPD_DryRun, HUSPD_Apply, HUSPD_ApplyNoBackup };
7374
7375	static int handleUpdateSettings_processFile (const char *filePath, HUSPD mode)
7376	{
7377	RTPrintf ("%s\n", filePath);
7378
7379	/// @todo later, when the settings file update funciton is reimplemented using
7380	/// libxslt (search for CFGLDR to find related parts of code below). Note that
7381	/// it doesn't make sense to enable this code since CFGLDR is no more
7382	/// available.
7383	#if 0
7384
7385	CFGHANDLE config = 0;
7386	char *errMsg = NULL;
7387
7388	int vrc = CFGLDRLoad (&config, filePath, NIL_RTFILE,
7389	NULL, false, NULL, //cfgLdrEntityResolver,
7390	&errMsg);
7391	if (VBOX_SUCCESS (vrc))
7392	{
7393	CFGNODE vbox = 0;
7394	CFGLDRGetNode (config, "VirtualBox", 0, &vbox);
7395	Bstr version;
7396	CFGLDRQueryBSTR (vbox, "version", version.asOutParam());
7397	CFGLDRReleaseNode (vbox);
7398
7399	RTPrintf (" current version : %ls\n", version.raw());
7400
7401	/// @todo (dmik) use cfgLdrEntityResolver later
7402	vrc = CFGLDRTransform (config, "SettingsConverter.xsl", NULL, &errMsg);
7403	if (VBOX_SUCCESS (vrc))
7404	{
7405	CFGLDRGetNode (config, "VirtualBox", 0, &vbox);
7406	CFGLDRQueryBSTR (vbox, "version", version.asOutParam());
7407	CFGLDRReleaseNode (vbox);
7408
7409	RTPrintf (" new version : %ls\n\n", version.raw());
7410
7411	if (mode != HUSPD_DryRun)
7412	{
7413	if (mode != HUSPD_ApplyNoBackup)
7414	{
7415	Utf8StrFmt filePathBak ("%s.bak", filePath);
7416	vrc = RTFileCopy (filePath, filePathBak);
7417	if (VBOX_FAILURE (vrc))
7418	{
7419	RTPrintf ("Error copying '%s' to '%s' (%Vrc)\n",
7420	filePath, filePathBak.raw(), vrc);
7421	}
7422	}
7423
7424	if (VBOX_SUCCESS (vrc))
7425	{
7426	vrc = CFGLDRSave (config, &errMsg);
7427	if (VBOX_FAILURE (vrc))
7428	{
7429	RTPrintf ("Error saving the settings file '%s' (%Vrc)%s%s\n",
7430	filePath, vrc,
7431	errMsg ? "\n" : "", errMsg ? errMsg : "");
7432	}
7433	}
7434	}
7435	}
7436	else
7437	{
7438	RTPrintf ("Could not convert the settings file '%s' (%Vrc)%s%s\n",
7439	filePath, vrc, errMsg ? "\n" : "", errMsg ? errMsg : "");
7440	}
7441
7442	CFGLDRFree (config);
7443	}
7444	else
7445	{
7446	RTPrintf ("Error loading the settings file '%s' (%Vrc)%s%s\n",
7447	filePath, vrc, errMsg ? "\n" : "", errMsg ? errMsg : "");
7448	}
7449
7450	if (errMsg)
7451	RTStrFree (errMsg);
7452
7453	return vrc;
7454
7455	#else
7456
7457	RTPrintf ("Error converting settings file '%s': "
7458	"THE FUNCTION IS TEMPORARILY DISABLED!\n");
7459	return 1;
7460
7461	#endif
7462	}
7463
7464	static int handleUpdateSettings_processDir (const char *dirPath, HUSPD mode,
7465	bool skipInvalid)
7466	{
7467	PRTDIR dir;
7468	int vrc = RTDirOpen (&dir, dirPath);
7469	if (VBOX_FAILURE (vrc))
7470	{
7471	return vrc;
7472	}
7473
7474	RTDIRENTRYEX entry;
7475	while (VBOX_SUCCESS (vrc))
7476	{
7477	vrc = RTDirReadEx (dir, &entry, NULL, RTFSOBJATTRADD_UNIX);
7478	if (VBOX_FAILURE (vrc))
7479	{
7480	if (vrc == VERR_NO_MORE_FILES)
7481	vrc = VINF_SUCCESS;
7482	else
7483	RTPrintf ("Error reading directory '%s' (%Vrc)\n", dirPath, vrc);
7484	break;
7485	}
7486
7487	if (RTFS_IS_DIRECTORY (entry.Info.Attr.fMode))
7488	{
7489	if (entry.szName[0] == '.' &&
7490	(entry.szName[1] == 0 \|\|
7491	(entry.szName[1] == '.' && entry.szName[2] == 0)))
7492	continue;
7493
7494	vrc = handleUpdateSettings_processDir (
7495	Utf8StrFmt ("%s%c%s", dirPath, RTPATH_DELIMITER, entry.szName),
7496	mode, skipInvalid);
7497	if (VBOX_FAILURE (vrc))
7498	break;
7499
7500	continue;
7501	}
7502	else if (RTFS_IS_FILE (entry.Info.Attr.fMode))
7503	{
7504	const char *ext = RTPathExt (entry.szName);
7505	if (!ext \|\| strcmp (ext, ".xml") != 0)
7506	continue;
7507	}
7508	else
7509	continue;
7510
7511	Utf8Str filePath = Utf8StrFmt ("%s%c%s", dirPath, RTPATH_DELIMITER,
7512	entry.szName);
7513
7514	vrc = handleUpdateSettings_processFile (filePath, mode);
7515
7516	if (skipInvalid)
7517	vrc = VINF_SUCCESS;
7518	}
7519
7520	RTDirClose (dir);
7521
7522	return vrc;
7523	}
7524
7525	static int handleUpdateSettings (int argc, char *argv[])
7526	{
7527	const char *dirOrFilePath = NULL;
7528	bool apply = false;
7529	bool nobackup = false;
7530	bool skipinvalid = false;
7531
7532	for (int i = 0; i < argc; i++)
7533	{
7534	if (i == 0 && argv[i][0] != '-')
7535	{
7536	dirOrFilePath = argv[i];
7537	}
7538	else if (argv[i][0] == '-')
7539	{
7540	if (strcmp (&argv[i][1], "apply") == 0)
7541	apply = true;
7542	else if (strcmp (&argv[i][1], "nobackup") == 0)
7543	nobackup = true;
7544	else if (strcmp (&argv[i][1], "skipinvalid") == 0)
7545	skipinvalid = true;
7546	else
7547	{
7548	return errorSyntax(USAGE_UPDATESETTINGS, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
7549	}
7550	}
7551	else
7552	{
7553	return errorSyntax(USAGE_UPDATESETTINGS, "Invalid parameter '%s'", Utf8Str(argv[i]).raw());
7554	}
7555	}
7556
7557	HUSPD mode = HUSPD_DryRun;
7558	if (apply)
7559	mode = nobackup ? HUSPD_ApplyNoBackup : HUSPD_Apply;
7560
7561	/// @todo later, when the settings file update funciton is reimplemented using
7562	/// libxslt (search for CFGLDR to find related parts of code below). Note that
7563	/// it doesn't make sense to enable this code since CFGLDR is no more
7564	/// available.
7565	#if 0
7566
7567	int vrc = CFGLDRInitialize();
7568	if (VBOX_FAILURE (vrc))
7569	{
7570	RTPrintf ("Could not initialize XML subsystem (%Vrc)\n", vrc);
7571	return 1;
7572	}
7573
7574	if (dirOrFilePath)
7575	{
7576	if (RTDirExists (dirOrFilePath))
7577	{
7578	char fullPath [RTPATH_MAX];
7579	vrc = RTPathReal (dirOrFilePath, fullPath, RTPATH_MAX);
7580	if (VBOX_FAILURE (vrc))
7581	{
7582	RTPrintf ("Invalid directory path '%s' (%Vrc)\n", dirOrFilePath, vrc);
7583	return 1;
7584	}
7585
7586	RTPrintf ("Updating settings files in the following directory:\n"
7587	"\n %s\n\n", fullPath);
7588
7589	vrc = handleUpdateSettings_processDir (dirOrFilePath, mode, skipinvalid);
7590	}
7591	else
7592	{
7593	vrc = handleUpdateSettings_processFile (dirOrFilePath, mode);
7594	}
7595	}
7596	else
7597	{
7598	char homeDir [RTPATH_MAX];
7599	vrc = GetVBoxUserHomeDirectory (homeDir, sizeof (homeDir));
7600
7601	AssertRC (vrc);
7602	if (VBOX_SUCCESS (vrc))
7603	{
7604	RTPrintf ("Updating settings files in the following VirtualBox Home Directory:\n"
7605	"\n %s\n\n", homeDir);
7606
7607	vrc = handleUpdateSettings_processDir (homeDir, mode, skipinvalid);
7608	}
7609	}
7610
7611	if (mode == HUSPD_DryRun)
7612	{
7613	RTPrintf ("NOTE: No actual changes to the setting files were made.\n"
7614	" Repeat the command with the -apply option supplied.\n");
7615	}
7616
7617	CFGLDRShutdown();
7618
7619	return VBOX_SUCCESS (vrc) ? 0 : 1;
7620
7621	#else
7622
7623	NOREF (mode);
7624
7625	RTPrintf ("THE SETTINGS FILE UPDATE FUNCTION IS TEMPORARILY DISABLED!\n");
7626	return 1;
7627
7628
7629	#endif
7630	}
7631
7632	// main
7633	///////////////////////////////////////////////////////////////////////////////
7634
7635	int main(int argc, char *argv[])
7636	{
7637	/*
7638	* Before we do anything, init the runtime without loading
7639	* the support driver.
7640	*/
7641	RTR3Init(false);
7642
7643	bool fShowLogo = true;
7644	int iCmd = 1;
7645	int iCmdArg;
7646
7647	for (int i = 1; i < argc \|\| argc <= iCmd; i++)
7648	{
7649	if ( argc <= iCmd
7650	\|\| (strcmp(argv[i], "help") == 0)
7651	\|\| (strcmp(argv[i], "-?") == 0)
7652	\|\| (strcmp(argv[i], "-h") == 0)
7653	\|\| (strcmp(argv[i], "-help") == 0)
7654	\|\| (strcmp(argv[i], "--help") == 0))
7655	{
7656	showLogo();
7657	printUsage(USAGE_ALL);
7658	return 0;
7659	}
7660	else if ( strcmp(argv[i], "-v") == 0
7661	\|\| strcmp(argv[i], "-version") == 0
7662	\|\| strcmp(argv[i], "-Version") == 0
7663	\|\| strcmp(argv[i], "--version") == 0)
7664	{
7665	/* Print version number, and do nothing else. */
7666	RTPrintf("%sr%d\n", VBOX_VERSION_STRING, VBoxSVNRev ());
7667	exit(0);
7668	}
7669	else if (strcmp(argv[i], "-nologo") == 0)
7670	{
7671	/* suppress the logo */
7672	fShowLogo = false;
7673	iCmd++;
7674	}
7675	else if (strcmp(argv[i], "-dumpopts") == 0)
7676	{
7677	/* Special option to dump really all commands,
7678	* even the ones not understood on this platform. */
7679	printUsage(USAGE_DUMPOPTS);
7680	return 0;
7681	}
7682	else
7683	{
7684	break;
7685	}
7686	}
7687
7688	iCmdArg = iCmd + 1;
7689
7690	if (fShowLogo)
7691	showLogo();
7692
7693	HRESULT rc;
7694
7695	CHECK_RC_RET (com::Initialize());
7696
7697	/*
7698	* The input is in the host OS'es codepage (NT guarantees ACP).
7699	* For VBox we use UTF-8 and convert to UCS-2 when calling (XP)COM APIs.
7700	* For simplicity, just convert the argv[] array here.
7701	*/
7702	for (int i = iCmdArg; i < argc; i++)
7703	{
7704	char *converted;
7705	RTStrCurrentCPToUtf8(&converted, argv[i]);
7706	argv[i] = converted;
7707	}
7708
7709	do
7710	{
7711	// scopes all the stuff till shutdown
7712	////////////////////////////////////////////////////////////////////////////
7713
7714	/* update settings command (no VirtualBox instantiation!) */
7715	if (argc >= iCmdArg && (strcmp(argv[iCmd], "updatesettings") == 0))
7716	{
7717	rc = handleUpdateSettings(argc - iCmdArg, argv + iCmdArg);
7718	break;
7719	}
7720
7721	/* convertdd: does not need a VirtualBox instantiation) */
7722	if (argc >= iCmdArg && (strcmp(argv[iCmd], "convertdd") == 0))
7723	{
7724	rc = handleConvertDDImage(argc - iCmdArg, argv + iCmdArg);
7725	break;
7726	}
7727
7728	ComPtr <IVirtualBox> virtualBox;
7729	ComPtr <ISession> session;
7730
7731	rc = virtualBox.createLocalObject (CLSID_VirtualBox);
7732	if (FAILED(rc))
7733	{
7734	RTPrintf ("[!] Failed to create the VirtualBox object!\n");
7735	PRINT_RC_MESSAGE (rc);
7736
7737	com::ErrorInfo info;
7738	if (!info.isFullAvailable() && !info.isBasicAvailable())
7739	RTPrintf ("[!] Most likely, the VirtualBox COM server is not running "
7740	"or failed to start.\n");
7741	else
7742	PRINT_ERROR_INFO (info);
7743	break;
7744	}
7745
7746	CHECK_RC_BREAK (session.createInprocObject (CLSID_Session));
7747
7748	/* create the event queue
7749	* (here it is necessary only to process remaining XPCOM/IPC events
7750	* after the session is closed) */
7751
7752	EventQueue eventQ;
7753
7754	/*
7755	* All registered command handlers
7756	*/
7757	struct
7758	{
7759	const char *command;
7760	PFNHANDLER handler;
7761	} commandHandlers[] =
7762	{
7763	{ "internalcommands", handleInternalCommands },
7764	{ "list", handleList },
7765	{ "showvminfo", handleShowVMInfo },
7766	{ "registervm", handleRegisterVM },
7767	{ "unregistervm", handleUnregisterVM },
7768	{ "createvdi", handleCreateVDI },
7769	{ "modifyvdi", handleModifyVDI },
7770	{ "addiscsidisk", handleAddiSCSIDisk },
7771	{ "createvm", handleCreateVM },
7772	{ "modifyvm", handleModifyVM },
7773	{ "clonevdi", handleCloneVDI },
7774	{ "startvm", handleStartVM },
7775	{ "controlvm", handleControlVM },
7776	{ "discardstate", handleDiscardState },
7777	{ "adoptstate", handleAdoptdState },
7778	{ "snapshot", handleSnapshot },
7779	{ "registerimage", handleRegisterImage },
7780	{ "unregisterimage", handleUnregisterImage },
7781	{ "showvdiinfo", handleShowVDIInfo },
7782	#ifdef RT_OS_WINDOWS
7783	{ "createhostif", handleCreateHostIF },
7784	{ "removehostif", handleRemoveHostIF },
7785	#endif
7786	{ "getextradata", handleGetExtraData },
7787	{ "setextradata", handleSetExtraData },
7788	{ "setproperty", handleSetProperty },
7789	{ "usbfilter", handleUSBFilter },
7790	{ "sharedfolder", handleSharedFolder },
7791	{ "vmstatistics", handleVMStatistics },
7792	{ NULL, NULL }
7793	};
7794
7795	int commandIndex;
7796	for (commandIndex = 0; commandHandlers[commandIndex].command != NULL; commandIndex++)
7797	{
7798	if (strcmp(commandHandlers[commandIndex].command, argv[iCmd]) == 0)
7799	{
7800	rc = commandHandlers[commandIndex].handler(argc - iCmdArg, &argv[iCmdArg], virtualBox, session);
7801	break;
7802	}
7803	}
7804	if (!commandHandlers[commandIndex].command)
7805	{
7806	rc = errorSyntax(USAGE_ALL, "Invalid command '%s'", Utf8Str(argv[iCmd]).raw());
7807	}
7808
7809	/* Although all handlers should always close the session if they open it,
7810	* we do it here just in case if some of the handlers contains a bug --
7811	* leaving the direct session not closed will turn the machine state to
7812	* Aborted which may have unwanted side effects like killing the saved
7813	* state file (if the machine was in the Saved state before). */
7814	session->Close();
7815
7816	// end "all-stuff" scope
7817	////////////////////////////////////////////////////////////////////////////
7818	}
7819	while (0);
7820
7821	com::Shutdown();
7822
7823	/*
7824	* Free converted argument vector
7825	*/
7826	for (int i = iCmdArg; i < argc; i++)
7827	RTStrFree(argv[i]);
7828
7829	return rc;
7830	}

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

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

Download in other formats: