VBoxManage.cpp@ 11142

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

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

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

Download in other formats: