VBoxManageModifyVM.cpp@ 68188

Last change on this file since 68188 was 66830, checked in by vboxsync, 8 years ago
VBoxManage: Adjustments for Visual C++ v12 / Visual Studio 2013. Dropped warning 4748.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 128.1 KB

Line
1	/* $Id: VBoxManageModifyVM.cpp 66830 2017-05-08 16:55:48Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of modifyvm command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#ifndef VBOX_ONLY_DOCS
23	#include <VBox/com/com.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27	#include <VBox/com/VirtualBox.h>
28	#endif /* !VBOX_ONLY_DOCS */
29
30	#include <iprt/cidr.h>
31	#include <iprt/ctype.h>
32	#include <iprt/file.h>
33	#include <iprt/param.h>
34	#include <iprt/path.h>
35	#include <iprt/stream.h>
36	#include <iprt/string.h>
37	#include <iprt/getopt.h>
38	#include <VBox/log.h>
39	#include "VBoxManage.h"
40
41	#ifndef VBOX_ONLY_DOCS
42	using namespace com;
43	/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
44	#if defined(_MSC_VER)
45	# pragma optimize("g", off)
46	# if _MSC_VER < RT_MSC_VER_VC120
47	# pragma warning(disable:4748)
48	# endif
49	#endif
50
51	enum
52	{
53	MODIFYVM_NAME = 1000,
54	MODIFYVM_GROUPS,
55	MODIFYVM_DESCRIPTION,
56	MODIFYVM_OSTYPE,
57	MODIFYVM_ICONFILE,
58	MODIFYVM_MEMORY,
59	MODIFYVM_PAGEFUSION,
60	MODIFYVM_VRAM,
61	MODIFYVM_FIRMWARE,
62	MODIFYVM_ACPI,
63	MODIFYVM_IOAPIC,
64	MODIFYVM_PAE,
65	MODIFYVM_LONGMODE,
66	MODIFYVM_CPUID_PORTABILITY,
67	MODIFYVM_TFRESET,
68	MODIFYVM_APIC,
69	MODIFYVM_X2APIC,
70	MODIFYVM_PARAVIRTPROVIDER,
71	MODIFYVM_PARAVIRTDEBUG,
72	MODIFYVM_HWVIRTEX,
73	MODIFYVM_NESTEDPAGING,
74	MODIFYVM_LARGEPAGES,
75	MODIFYVM_VTXVPID,
76	MODIFYVM_VTXUX,
77	MODIFYVM_CPUS,
78	MODIFYVM_CPUHOTPLUG,
79	MODIFYVM_CPU_PROFILE,
80	MODIFYVM_PLUGCPU,
81	MODIFYVM_UNPLUGCPU,
82	MODIFYVM_SETCPUID,
83	MODIFYVM_DELCPUID,
84	MODIFYVM_DELALLCPUID,
85	MODIFYVM_GRAPHICSCONTROLLER,
86	MODIFYVM_MONITORCOUNT,
87	MODIFYVM_ACCELERATE3D,
88	#ifdef VBOX_WITH_VIDEOHWACCEL
89	MODIFYVM_ACCELERATE2DVIDEO,
90	#endif
91	MODIFYVM_BIOSLOGOFADEIN,
92	MODIFYVM_BIOSLOGOFADEOUT,
93	MODIFYVM_BIOSLOGODISPLAYTIME,
94	MODIFYVM_BIOSLOGOIMAGEPATH,
95	MODIFYVM_BIOSBOOTMENU,
96	MODIFYVM_BIOSAPIC,
97	MODIFYVM_BIOSSYSTEMTIMEOFFSET,
98	MODIFYVM_BIOSPXEDEBUG,
99	MODIFYVM_BOOT,
100	MODIFYVM_HDA, // deprecated
101	MODIFYVM_HDB, // deprecated
102	MODIFYVM_HDD, // deprecated
103	MODIFYVM_IDECONTROLLER, // deprecated
104	MODIFYVM_SATAPORTCOUNT, // deprecated
105	MODIFYVM_SATAPORT, // deprecated
106	MODIFYVM_SATA, // deprecated
107	MODIFYVM_SCSIPORT, // deprecated
108	MODIFYVM_SCSITYPE, // deprecated
109	MODIFYVM_SCSI, // deprecated
110	MODIFYVM_DVDPASSTHROUGH, // deprecated
111	MODIFYVM_DVD, // deprecated
112	MODIFYVM_FLOPPY, // deprecated
113	MODIFYVM_NICTRACEFILE,
114	MODIFYVM_NICTRACE,
115	MODIFYVM_NICPROPERTY,
116	MODIFYVM_NICTYPE,
117	MODIFYVM_NICSPEED,
118	MODIFYVM_NICBOOTPRIO,
119	MODIFYVM_NICPROMISC,
120	MODIFYVM_NICBWGROUP,
121	MODIFYVM_NIC,
122	MODIFYVM_CABLECONNECTED,
123	MODIFYVM_BRIDGEADAPTER,
124	MODIFYVM_HOSTONLYADAPTER,
125	MODIFYVM_INTNET,
126	MODIFYVM_GENERICDRV,
127	MODIFYVM_NATNETWORKNAME,
128	MODIFYVM_NATNET,
129	MODIFYVM_NATBINDIP,
130	MODIFYVM_NATSETTINGS,
131	MODIFYVM_NATPF,
132	MODIFYVM_NATALIASMODE,
133	MODIFYVM_NATTFTPPREFIX,
134	MODIFYVM_NATTFTPFILE,
135	MODIFYVM_NATTFTPSERVER,
136	MODIFYVM_NATDNSPASSDOMAIN,
137	MODIFYVM_NATDNSPROXY,
138	MODIFYVM_NATDNSHOSTRESOLVER,
139	MODIFYVM_MACADDRESS,
140	MODIFYVM_HIDPTR,
141	MODIFYVM_HIDKBD,
142	MODIFYVM_UARTMODE,
143	MODIFYVM_UART,
144	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
145	MODIFYVM_LPTMODE,
146	MODIFYVM_LPT,
147	#endif
148	MODIFYVM_GUESTMEMORYBALLOON,
149	MODIFYVM_AUDIOCONTROLLER,
150	MODIFYVM_AUDIOCODEC,
151	MODIFYVM_AUDIO,
152	MODIFYVM_CLIPBOARD,
153	MODIFYVM_DRAGANDDROP,
154	MODIFYVM_VRDPPORT, /* VRDE: deprecated */
155	MODIFYVM_VRDPADDRESS, /* VRDE: deprecated */
156	MODIFYVM_VRDPAUTHTYPE, /* VRDE: deprecated */
157	MODIFYVM_VRDPMULTICON, /* VRDE: deprecated */
158	MODIFYVM_VRDPREUSECON, /* VRDE: deprecated */
159	MODIFYVM_VRDPVIDEOCHANNEL, /* VRDE: deprecated */
160	MODIFYVM_VRDPVIDEOCHANNELQUALITY, /* VRDE: deprecated */
161	MODIFYVM_VRDP, /* VRDE: deprecated */
162	MODIFYVM_VRDEPROPERTY,
163	MODIFYVM_VRDEPORT,
164	MODIFYVM_VRDEADDRESS,
165	MODIFYVM_VRDEAUTHTYPE,
166	MODIFYVM_VRDEAUTHLIBRARY,
167	MODIFYVM_VRDEMULTICON,
168	MODIFYVM_VRDEREUSECON,
169	MODIFYVM_VRDEVIDEOCHANNEL,
170	MODIFYVM_VRDEVIDEOCHANNELQUALITY,
171	MODIFYVM_VRDE_EXTPACK,
172	MODIFYVM_VRDE,
173	MODIFYVM_RTCUSEUTC,
174	MODIFYVM_USBRENAME,
175	MODIFYVM_USBXHCI,
176	MODIFYVM_USBEHCI,
177	MODIFYVM_USB,
178	MODIFYVM_SNAPSHOTFOLDER,
179	MODIFYVM_TELEPORTER_ENABLED,
180	MODIFYVM_TELEPORTER_PORT,
181	MODIFYVM_TELEPORTER_ADDRESS,
182	MODIFYVM_TELEPORTER_PASSWORD,
183	MODIFYVM_TELEPORTER_PASSWORD_FILE,
184	MODIFYVM_TRACING_ENABLED,
185	MODIFYVM_TRACING_CONFIG,
186	MODIFYVM_TRACING_ALLOW_VM_ACCESS,
187	MODIFYVM_HARDWARE_UUID,
188	MODIFYVM_HPET,
189	MODIFYVM_IOCACHE,
190	MODIFYVM_IOCACHESIZE,
191	MODIFYVM_FAULT_TOLERANCE,
192	MODIFYVM_FAULT_TOLERANCE_ADDRESS,
193	MODIFYVM_FAULT_TOLERANCE_PORT,
194	MODIFYVM_FAULT_TOLERANCE_PASSWORD,
195	MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL,
196	MODIFYVM_CPU_EXECTUION_CAP,
197	MODIFYVM_AUTOSTART_ENABLED,
198	MODIFYVM_AUTOSTART_DELAY,
199	MODIFYVM_AUTOSTOP_TYPE,
200	#ifdef VBOX_WITH_PCI_PASSTHROUGH
201	MODIFYVM_ATTACH_PCI,
202	MODIFYVM_DETACH_PCI,
203	#endif
204	#ifdef VBOX_WITH_USB_CARDREADER
205	MODIFYVM_USBCARDREADER,
206	#endif
207	#ifdef VBOX_WITH_VIDEOREC
208	MODIFYVM_VIDEOCAP,
209	MODIFYVM_VIDEOCAP_SCREENS,
210	MODIFYVM_VIDEOCAP_FILENAME,
211	MODIFYVM_VIDEOCAP_WIDTH,
212	MODIFYVM_VIDEOCAP_HEIGHT,
213	MODIFYVM_VIDEOCAP_RES,
214	MODIFYVM_VIDEOCAP_RATE,
215	MODIFYVM_VIDEOCAP_FPS,
216	MODIFYVM_VIDEOCAP_MAXTIME,
217	MODIFYVM_VIDEOCAP_MAXSIZE,
218	MODIFYVM_VIDEOCAP_OPTIONS,
219	#endif
220	MODIFYVM_CHIPSET,
221	MODIFYVM_DEFAULTFRONTEND
222	};
223
224	static const RTGETOPTDEF g_aModifyVMOptions[] =
225	{
226	/** @todo Convert to dash separated names like --triple-fault-reset! Please
227	* do that for all new options as we don't need more character soups
228	* around VirtualBox - typedefs more than covers that demand! */
229	{ "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
230	{ "--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING },
231	{ "--description", MODIFYVM_DESCRIPTION, RTGETOPT_REQ_STRING },
232	{ "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
233	{ "--iconfile", MODIFYVM_ICONFILE, RTGETOPT_REQ_STRING },
234	{ "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
235	{ "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF },
236	{ "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
237	{ "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
238	{ "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
239	{ "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
240	{ "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
241	{ "--longmode", MODIFYVM_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF },
242	{ "--cpuid-portability-level", MODIFYVM_CPUID_PORTABILITY, RTGETOPT_REQ_UINT32 },
243	{ "--triplefaultreset", MODIFYVM_TFRESET, RTGETOPT_REQ_BOOL_ONOFF },
244	{ "--apic", MODIFYVM_APIC, RTGETOPT_REQ_BOOL_ONOFF },
245	{ "--x2apic", MODIFYVM_X2APIC, RTGETOPT_REQ_BOOL_ONOFF },
246	{ "--paravirtprovider", MODIFYVM_PARAVIRTPROVIDER, RTGETOPT_REQ_STRING },
247	{ "--paravirtdebug", MODIFYVM_PARAVIRTDEBUG, RTGETOPT_REQ_STRING },
248	{ "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
249	{ "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
250	{ "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
251	{ "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
252	{ "--vtxux", MODIFYVM_VTXUX, RTGETOPT_REQ_BOOL_ONOFF },
253	{ "--cpuidset", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX},
254	{ "--cpuidremove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX},
255	{ "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
256	{ "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
257	{ "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
258	{ "--cpu-profile", MODIFYVM_CPU_PROFILE, RTGETOPT_REQ_STRING },
259	{ "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
260	{ "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
261	{ "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32 },
262	{ "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
263	{ "--graphicscontroller", MODIFYVM_GRAPHICSCONTROLLER, RTGETOPT_REQ_STRING },
264	{ "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
265	{ "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
266	#ifdef VBOX_WITH_VIDEOHWACCEL
267	{ "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
268	#endif
269	{ "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
270	{ "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
271	{ "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
272	{ "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
273	{ "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
274	{ "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
275	{ "--biosapic", MODIFYVM_BIOSAPIC, RTGETOPT_REQ_STRING },
276	{ "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
277	{ "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
278	{ "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
279	{ "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
280	{ "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
281	{ "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
282	{ "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
283	{ "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
284	{ "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
285	{ "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
286	{ "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
287	{ "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
288	{ "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
289	{ "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
290	{ "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
291	{ "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
292	{ "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
293	{ "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
294	{ "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
295	{ "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_INDEX },
296	{ "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_INDEX },
297	{ "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
298	{ "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
299	{ "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
300	{ "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
301	{ "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
302	{ "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
303	{ "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
304	{ "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
305	{ "--nat-network", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
306	{ "--natnetwork", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
307	{ "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
308	{ "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
309	{ "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
310	{ "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
311	{ "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
312	{ "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
313	{ "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
314	{ "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
315	{ "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
316	{ "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
317	{ "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
318	{ "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
319	{ "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
320	{ "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
321	{ "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
322	{ "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
323	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
324	{ "--lptmode", MODIFYVM_LPTMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
325	{ "--lpt", MODIFYVM_LPT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
326	#endif
327	{ "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
328	{ "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
329	{ "--audiocodec", MODIFYVM_AUDIOCODEC, RTGETOPT_REQ_STRING },
330	{ "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
331	{ "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
332	{ "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING },
333	{ "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING }, /* deprecated */
334	{ "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING }, /* deprecated */
335	{ "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING }, /* deprecated */
336	{ "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
337	{ "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
338	{ "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
339	{ "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, /* deprecated */
340	{ "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
341	{ "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING },
342	{ "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING },
343	{ "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING },
344	{ "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING },
345	{ "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING },
346	{ "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
347	{ "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
348	{ "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF },
349	{ "--vrdevideochannelquality", MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING },
350	{ "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING },
351	{ "--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF },
352	{ "--usbrename", MODIFYVM_USBRENAME, RTGETOPT_REQ_STRING },
353	{ "--usbxhci", MODIFYVM_USBXHCI, RTGETOPT_REQ_BOOL_ONOFF },
354	{ "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
355	{ "--usb", MODIFYVM_USB, RTGETOPT_REQ_BOOL_ONOFF },
356	{ "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
357	{ "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
358	{ "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
359	{ "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
360	{ "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
361	{ "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
362	{ "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING },
363	{ "--tracing-enabled", MODIFYVM_TRACING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
364	{ "--tracing-config", MODIFYVM_TRACING_CONFIG, RTGETOPT_REQ_STRING },
365	{ "--tracing-allow-vm-access", MODIFYVM_TRACING_ALLOW_VM_ACCESS, RTGETOPT_REQ_BOOL_ONOFF },
366	{ "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
367	{ "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
368	{ "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
369	{ "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
370	{ "--faulttolerance", MODIFYVM_FAULT_TOLERANCE, RTGETOPT_REQ_STRING },
371	{ "--faulttoleranceaddress", MODIFYVM_FAULT_TOLERANCE_ADDRESS, RTGETOPT_REQ_STRING },
372	{ "--faulttoleranceport", MODIFYVM_FAULT_TOLERANCE_PORT, RTGETOPT_REQ_UINT32 },
373	{ "--faulttolerancepassword", MODIFYVM_FAULT_TOLERANCE_PASSWORD, RTGETOPT_REQ_STRING },
374	{ "--faulttolerancesyncinterval", MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, RTGETOPT_REQ_UINT32 },
375	{ "--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING },
376	#ifdef VBOX_WITH_VIDEOREC
377	{ "--videocap", MODIFYVM_VIDEOCAP, RTGETOPT_REQ_BOOL_ONOFF },
378	{ "--vcpenabled", MODIFYVM_VIDEOCAP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
379	{ "--videocapscreens", MODIFYVM_VIDEOCAP_SCREENS, RTGETOPT_REQ_STRING },
380	{ "--vcpscreens", MODIFYVM_VIDEOCAP_SCREENS, RTGETOPT_REQ_STRING }, /* deprecated */
381	{ "--videocapfile", MODIFYVM_VIDEOCAP_FILENAME, RTGETOPT_REQ_STRING },
382	{ "--vcpfile", MODIFYVM_VIDEOCAP_FILENAME, RTGETOPT_REQ_STRING }, /* deprecated */
383	{ "--videocapres", MODIFYVM_VIDEOCAP_RES, RTGETOPT_REQ_STRING },
384	{ "--vcpwidth", MODIFYVM_VIDEOCAP_WIDTH, RTGETOPT_REQ_UINT32 }, /* deprecated */
385	{ "--vcpheight", MODIFYVM_VIDEOCAP_HEIGHT, RTGETOPT_REQ_UINT32 }, /* deprecated */
386	{ "--videocaprate", MODIFYVM_VIDEOCAP_RATE, RTGETOPT_REQ_UINT32 },
387	{ "--vcprate", MODIFYVM_VIDEOCAP_RATE, RTGETOPT_REQ_UINT32 }, /* deprecated */
388	{ "--videocapfps", MODIFYVM_VIDEOCAP_FPS, RTGETOPT_REQ_UINT32 },
389	{ "--vcpfps", MODIFYVM_VIDEOCAP_FPS, RTGETOPT_REQ_UINT32 }, /* deprecated */
390	{ "--videocapmaxtime", MODIFYVM_VIDEOCAP_MAXTIME, RTGETOPT_REQ_INT32 },
391	{ "--vcpmaxtime", MODIFYVM_VIDEOCAP_MAXTIME, RTGETOPT_REQ_INT32 }, /* deprecated */
392	{ "--videocapmaxsize", MODIFYVM_VIDEOCAP_MAXSIZE, RTGETOPT_REQ_INT32 },
393	{ "--vcpmaxsize", MODIFYVM_VIDEOCAP_MAXSIZE, RTGETOPT_REQ_INT32 }, /* deprecated */
394	{ "--videocapopts", MODIFYVM_VIDEOCAP_OPTIONS, RTGETOPT_REQ_STRING },
395	{ "--vcpoptions", MODIFYVM_VIDEOCAP_OPTIONS, RTGETOPT_REQ_STRING }, /* deprecated */
396	#endif
397	{ "--autostart-enabled", MODIFYVM_AUTOSTART_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
398	{ "--autostart-delay", MODIFYVM_AUTOSTART_DELAY, RTGETOPT_REQ_UINT32 },
399	{ "--autostop-type", MODIFYVM_AUTOSTOP_TYPE, RTGETOPT_REQ_STRING },
400	#ifdef VBOX_WITH_PCI_PASSTHROUGH
401	{ "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING },
402	{ "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING },
403	#endif
404	#ifdef VBOX_WITH_USB_CARDREADER
405	{ "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF },
406	#endif
407	{ "--defaultfrontend", MODIFYVM_DEFAULTFRONTEND, RTGETOPT_REQ_STRING },
408	};
409
410	static void vrdeWarningDeprecatedOption(const char *pszOption)
411	{
412	RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption);
413	}
414
415	/** Parse PCI address in format 01:02.03 and convert it to the numeric representation. */
416	static int32_t parsePci(const char* szPciAddr)
417	{
418	char* pszNext = (char*)szPciAddr;
419	int rc;
420	uint8_t aVals[3] = {0, 0, 0};
421
422	rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
423	if (RT_FAILURE(rc) \|\| pszNext == NULL \|\| *pszNext != ':')
424	return -1;
425
426	rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
427	if (RT_FAILURE(rc) \|\| pszNext == NULL \|\| *pszNext != '.')
428	return -1;
429
430	rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
431	if (RT_FAILURE(rc) \|\| pszNext == NULL)
432	return -1;
433
434	return (aVals[0] << 8) \| (aVals[1] << 3) \| (aVals[2] << 0);
435	}
436
437	void parseGroups(const char pcszGroups, com::SafeArray<BSTR> pGroups)
438	{
439	while (pcszGroups)
440	{
441	char *pComma = RTStrStr(pcszGroups, ",");
442	if (pComma)
443	{
444	Bstr(pcszGroups, pComma - pcszGroups).detachTo(pGroups->appendedRaw());
445	pcszGroups = pComma + 1;
446	}
447	else
448	{
449	Bstr(pcszGroups).detachTo(pGroups->appendedRaw());
450	pcszGroups = NULL;
451	}
452	}
453	}
454
455	#ifdef VBOX_WITH_VIDEOREC
456	static int parseScreens(const char pcszScreens, com::SafeArray<BOOL> pScreens)
457	{
458	while (pcszScreens && *pcszScreens)
459	{
460	char *pszNext;
461	uint32_t iScreen;
462	int rc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
463	if (RT_FAILURE(rc))
464	return 1;
465	if (iScreen >= pScreens->size())
466	return 1;
467	if (pszNext && *pszNext)
468	{
469	pszNext = RTStrStripL(pszNext);
470	if (*pszNext != ',')
471	return 1;
472	pszNext++;
473	}
474	(*pScreens)[iScreen] = true;
475	pcszScreens = pszNext;
476	}
477	return 0;
478	}
479	#endif
480
481	static int parseNum(uint32_t uIndex, unsigned cMaxIndex, const char *pszName)
482	{
483	if ( uIndex >= 1
484	&& uIndex <= cMaxIndex)
485	return uIndex;
486	errorArgument("Invalid %s number %u", pszName, uIndex);
487	return 0;
488	}
489
490	RTEXITCODE handleModifyVM(HandlerArg *a)
491	{
492	int c;
493	HRESULT rc;
494	Bstr name;
495
496	/* VM ID + at least one parameter. Parameter arguments are checked
497	* individually. */
498	if (a->argc < 2)
499	return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
500
501	/* try to find the given sessionMachine */
502	ComPtr<IMachine> machine;
503	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
504	machine.asOutParam()), RTEXITCODE_FAILURE);
505
506
507	/* Get the number of network adapters */
508	ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine);
509
510	/* open a session for the VM */
511	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
512
513	/* get the mutable session sessionMachine */
514	ComPtr<IMachine> sessionMachine;
515	CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
516
517	ComPtr<IBIOSSettings> biosSettings;
518	sessionMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
519
520	RTGETOPTSTATE GetOptState;
521	RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
522	RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
523
524	RTGETOPTUNION ValueUnion;
525	while ( SUCCEEDED (rc)
526	&& (c = RTGetOpt(&GetOptState, &ValueUnion)))
527	{
528	switch (c)
529	{
530	case MODIFYVM_NAME:
531	{
532	CHECK_ERROR(sessionMachine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
533	break;
534	}
535	case MODIFYVM_GROUPS:
536	{
537	com::SafeArray<BSTR> groups;
538	parseGroups(ValueUnion.psz, &groups);
539	CHECK_ERROR(sessionMachine, COMSETTER(Groups)(ComSafeArrayAsInParam(groups)));
540	break;
541	}
542	case MODIFYVM_DESCRIPTION:
543	{
544	CHECK_ERROR(sessionMachine, COMSETTER(Description)(Bstr(ValueUnion.psz).raw()));
545	break;
546	}
547	case MODIFYVM_OSTYPE:
548	{
549	ComPtr<IGuestOSType> guestOSType;
550	CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
551	guestOSType.asOutParam()));
552	if (SUCCEEDED(rc) && guestOSType)
553	{
554	CHECK_ERROR(sessionMachine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
555	}
556	else
557	{
558	errorArgument("Invalid guest OS type '%s'", ValueUnion.psz);
559	rc = E_FAIL;
560	}
561	break;
562	}
563
564	case MODIFYVM_ICONFILE:
565	{
566	RTFILE iconFile;
567	int vrc = RTFileOpen(&iconFile, ValueUnion.psz, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
568	if (RT_FAILURE(vrc))
569	{
570	RTMsgError("Cannot open file \"%s\": %Rrc", ValueUnion.psz, vrc);
571	rc = E_FAIL;
572	break;
573	}
574	uint64_t cbSize;
575	vrc = RTFileGetSize(iconFile, &cbSize);
576	if (RT_FAILURE(vrc))
577	{
578	RTMsgError("Cannot get size of file \"%s\": %Rrc", ValueUnion.psz, vrc);
579	rc = E_FAIL;
580	break;
581	}
582	if (cbSize > _256K)
583	{
584	RTMsgError("File \"%s\" is bigger than 256KByte", ValueUnion.psz);
585	rc = E_FAIL;
586	break;
587	}
588	SafeArray<BYTE> icon((size_t)cbSize);
589	rc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
590	if (RT_FAILURE(vrc))
591	{
592	RTMsgError("Cannot read contents of file \"%s\": %Rrc", ValueUnion.psz, vrc);
593	rc = E_FAIL;
594	break;
595	}
596	RTFileClose(iconFile);
597	CHECK_ERROR(sessionMachine, COMSETTER(Icon)(ComSafeArrayAsInParam(icon)));
598	break;
599	}
600
601	case MODIFYVM_MEMORY:
602	{
603	CHECK_ERROR(sessionMachine, COMSETTER(MemorySize)(ValueUnion.u32));
604	break;
605	}
606
607	case MODIFYVM_PAGEFUSION:
608	{
609	CHECK_ERROR(sessionMachine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
610	break;
611	}
612
613	case MODIFYVM_VRAM:
614	{
615	CHECK_ERROR(sessionMachine, COMSETTER(VRAMSize)(ValueUnion.u32));
616	break;
617	}
618
619	case MODIFYVM_FIRMWARE:
620	{
621	if (!RTStrICmp(ValueUnion.psz, "efi"))
622	{
623	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI));
624	}
625	else if (!RTStrICmp(ValueUnion.psz, "efi32"))
626	{
627	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
628	}
629	else if (!RTStrICmp(ValueUnion.psz, "efi64"))
630	{
631	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
632	}
633	else if (!RTStrICmp(ValueUnion.psz, "efidual"))
634	{
635	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
636	}
637	else if (!RTStrICmp(ValueUnion.psz, "bios"))
638	{
639	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
640	}
641	else
642	{
643	errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
644	rc = E_FAIL;
645	}
646	break;
647	}
648
649	case MODIFYVM_ACPI:
650	{
651	CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
652	break;
653	}
654
655	case MODIFYVM_IOAPIC:
656	{
657	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
658	break;
659	}
660
661	case MODIFYVM_PAE:
662	{
663	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
664	break;
665	}
666
667	case MODIFYVM_LONGMODE:
668	{
669	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_LongMode, ValueUnion.f));
670	break;
671	}
672
673	case MODIFYVM_CPUID_PORTABILITY:
674	{
675	CHECK_ERROR(sessionMachine, COMSETTER(CPUIDPortabilityLevel)(ValueUnion.u32));
676	break;
677	}
678
679	case MODIFYVM_TFRESET:
680	{
681	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_TripleFaultReset, ValueUnion.f));
682	break;
683	}
684
685	case MODIFYVM_APIC:
686	{
687	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_APIC, ValueUnion.f));
688	break;
689	}
690
691	case MODIFYVM_X2APIC:
692	{
693	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_X2APIC, ValueUnion.f));
694	break;
695	}
696
697	case MODIFYVM_PARAVIRTPROVIDER:
698	{
699	if ( !RTStrICmp(ValueUnion.psz, "none")
700	\|\| !RTStrICmp(ValueUnion.psz, "disabled"))
701	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_None));
702	else if (!RTStrICmp(ValueUnion.psz, "default"))
703	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Default));
704	else if (!RTStrICmp(ValueUnion.psz, "legacy"))
705	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Legacy));
706	else if (!RTStrICmp(ValueUnion.psz, "minimal"))
707	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Minimal));
708	else if (!RTStrICmp(ValueUnion.psz, "hyperv"))
709	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_HyperV));
710	else if (!RTStrICmp(ValueUnion.psz, "kvm"))
711	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_KVM));
712	else
713	{
714	errorArgument("Invalid --paravirtprovider argument '%s'", ValueUnion.psz);
715	rc = E_FAIL;
716	}
717	break;
718	}
719
720	case MODIFYVM_PARAVIRTDEBUG:
721	{
722	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtDebug)(Bstr(ValueUnion.psz).raw()));
723	break;
724	}
725
726	case MODIFYVM_HWVIRTEX:
727	{
728	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
729	break;
730	}
731
732	case MODIFYVM_SETCPUID:
733	{
734	uint32_t id = ValueUnion.u32;
735	uint32_t aValue[4];
736
737	for (unsigned i = 0; i < 4; i++)
738	{
739	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX);
740	if (RT_FAILURE(vrc))
741	return errorSyntax(USAGE_MODIFYVM,
742	"Missing or Invalid argument to '%s'",
743	GetOptState.pDef->pszLong);
744	aValue[i] = ValueUnion.u32;
745	}
746	CHECK_ERROR(sessionMachine, SetCPUIDLeaf(id, aValue[0], aValue[1], aValue[2], aValue[3]));
747	break;
748	}
749
750	case MODIFYVM_DELCPUID:
751	{
752	CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.u32));
753	break;
754	}
755
756	case MODIFYVM_DELALLCPUID:
757	{
758	CHECK_ERROR(sessionMachine, RemoveAllCPUIDLeaves());
759	break;
760	}
761
762	case MODIFYVM_NESTEDPAGING:
763	{
764	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
765	break;
766	}
767
768	case MODIFYVM_LARGEPAGES:
769	{
770	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
771	break;
772	}
773
774	case MODIFYVM_VTXVPID:
775	{
776	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
777	break;
778	}
779
780	case MODIFYVM_VTXUX:
781	{
782	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, ValueUnion.f));
783	break;
784	}
785
786	case MODIFYVM_CPUS:
787	{
788	CHECK_ERROR(sessionMachine, COMSETTER(CPUCount)(ValueUnion.u32));
789	break;
790	}
791
792	case MODIFYVM_RTCUSEUTC:
793	{
794	CHECK_ERROR(sessionMachine, COMSETTER(RTCUseUTC)(ValueUnion.f));
795	break;
796	}
797
798	case MODIFYVM_CPUHOTPLUG:
799	{
800	CHECK_ERROR(sessionMachine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
801	break;
802	}
803
804	case MODIFYVM_CPU_PROFILE:
805	{
806	CHECK_ERROR(sessionMachine, COMSETTER(CPUProfile)(Bstr(ValueUnion.psz).raw()));
807	break;
808	}
809
810	case MODIFYVM_PLUGCPU:
811	{
812	CHECK_ERROR(sessionMachine, HotPlugCPU(ValueUnion.u32));
813	break;
814	}
815
816	case MODIFYVM_UNPLUGCPU:
817	{
818	CHECK_ERROR(sessionMachine, HotUnplugCPU(ValueUnion.u32));
819	break;
820	}
821
822	case MODIFYVM_CPU_EXECTUION_CAP:
823	{
824	CHECK_ERROR(sessionMachine, COMSETTER(CPUExecutionCap)(ValueUnion.u32));
825	break;
826	}
827
828	case MODIFYVM_GRAPHICSCONTROLLER:
829	{
830	if ( !RTStrICmp(ValueUnion.psz, "none")
831	\|\| !RTStrICmp(ValueUnion.psz, "disabled"))
832	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_Null));
833	else if ( !RTStrICmp(ValueUnion.psz, "vboxvga")
834	\|\| !RTStrICmp(ValueUnion.psz, "vbox")
835	\|\| !RTStrICmp(ValueUnion.psz, "vga")
836	\|\| !RTStrICmp(ValueUnion.psz, "vesa"))
837	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxVGA));
838	#ifdef VBOX_WITH_VMSVGA
839	else if ( !RTStrICmp(ValueUnion.psz, "vmsvga")
840	\|\| !RTStrICmp(ValueUnion.psz, "vmware"))
841	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VMSVGA));
842	#endif
843	else
844	{
845	errorArgument("Invalid --graphicscontroller argument '%s'", ValueUnion.psz);
846	rc = E_FAIL;
847	}
848	break;
849	}
850
851	case MODIFYVM_MONITORCOUNT:
852	{
853	CHECK_ERROR(sessionMachine, COMSETTER(MonitorCount)(ValueUnion.u32));
854	break;
855	}
856
857	case MODIFYVM_ACCELERATE3D:
858	{
859	CHECK_ERROR(sessionMachine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
860	break;
861	}
862
863	#ifdef VBOX_WITH_VIDEOHWACCEL
864	case MODIFYVM_ACCELERATE2DVIDEO:
865	{
866	CHECK_ERROR(sessionMachine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
867	break;
868	}
869	#endif
870
871	case MODIFYVM_BIOSLOGOFADEIN:
872	{
873	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
874	break;
875	}
876
877	case MODIFYVM_BIOSLOGOFADEOUT:
878	{
879	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
880	break;
881	}
882
883	case MODIFYVM_BIOSLOGODISPLAYTIME:
884	{
885	CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
886	break;
887	}
888
889	case MODIFYVM_BIOSLOGOIMAGEPATH:
890	{
891	CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
892	break;
893	}
894
895	case MODIFYVM_BIOSBOOTMENU:
896	{
897	if (!RTStrICmp(ValueUnion.psz, "disabled"))
898	{
899	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
900	}
901	else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
902	{
903	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
904	}
905	else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
906	{
907	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
908	}
909	else
910	{
911	errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
912	rc = E_FAIL;
913	}
914	break;
915	}
916
917	case MODIFYVM_BIOSAPIC:
918	{
919	if (!RTStrICmp(ValueUnion.psz, "disabled"))
920	{
921	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_Disabled));
922	}
923	else if ( !RTStrICmp(ValueUnion.psz, "apic")
924	\|\| !RTStrICmp(ValueUnion.psz, "lapic")
925	\|\| !RTStrICmp(ValueUnion.psz, "xapic"))
926	{
927	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_APIC));
928	}
929	else if (!RTStrICmp(ValueUnion.psz, "x2apic"))
930	{
931	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_X2APIC));
932	}
933	else
934	{
935	errorArgument("Invalid --biosapic argument '%s'", ValueUnion.psz);
936	rc = E_FAIL;
937	}
938	break;
939	}
940
941	case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
942	{
943	CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
944	break;
945	}
946
947	case MODIFYVM_BIOSPXEDEBUG:
948	{
949	CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
950	break;
951	}
952
953	case MODIFYVM_BOOT:
954	{
955	if (!RTStrICmp(ValueUnion.psz, "none"))
956	{
957	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
958	}
959	else if (!RTStrICmp(ValueUnion.psz, "floppy"))
960	{
961	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
962	}
963	else if (!RTStrICmp(ValueUnion.psz, "dvd"))
964	{
965	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
966	}
967	else if (!RTStrICmp(ValueUnion.psz, "disk"))
968	{
969	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
970	}
971	else if (!RTStrICmp(ValueUnion.psz, "net"))
972	{
973	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
974	}
975	else
976	return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
977	break;
978	}
979
980	case MODIFYVM_HDA: // deprecated
981	case MODIFYVM_HDB: // deprecated
982	case MODIFYVM_HDD: // deprecated
983	case MODIFYVM_SATAPORT: // deprecated
984	{
985	uint32_t u1 = 0, u2 = 0;
986	Bstr bstrController = L"IDE Controller";
987
988	switch (c)
989	{
990	case MODIFYVM_HDA: // deprecated
991	u1 = 0;
992	break;
993
994	case MODIFYVM_HDB: // deprecated
995	u1 = 0;
996	u2 = 1;
997	break;
998
999	case MODIFYVM_HDD: // deprecated
1000	u1 = 1;
1001	u2 = 1;
1002	break;
1003
1004	case MODIFYVM_SATAPORT: // deprecated
1005	u1 = GetOptState.uIndex;
1006	bstrController = L"SATA";
1007	break;
1008	}
1009
1010	if (!RTStrICmp(ValueUnion.psz, "none"))
1011	{
1012	sessionMachine->DetachDevice(bstrController.raw(), u1, u2);
1013	}
1014	else
1015	{
1016	ComPtr<IMedium> hardDisk;
1017	rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1018	AccessMode_ReadWrite, hardDisk,
1019	false /* fForceNewUuidOnOpen */,
1020	false /* fSilent */);
1021	if (FAILED(rc))
1022	break;
1023	if (hardDisk)
1024	{
1025	CHECK_ERROR(sessionMachine, AttachDevice(bstrController.raw(),
1026	u1, u2,
1027	DeviceType_HardDisk,
1028	hardDisk));
1029	}
1030	else
1031	rc = E_FAIL;
1032	}
1033	break;
1034	}
1035
1036	case MODIFYVM_IDECONTROLLER: // deprecated
1037	{
1038	ComPtr<IStorageController> storageController;
1039	CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
1040	storageController.asOutParam()));
1041
1042	if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
1043	{
1044	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
1045	}
1046	else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
1047	{
1048	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
1049	}
1050	else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
1051	{
1052	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
1053	}
1054	else
1055	{
1056	errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
1057	rc = E_FAIL;
1058	}
1059	break;
1060	}
1061
1062	case MODIFYVM_SATAPORTCOUNT: // deprecated
1063	{
1064	ComPtr<IStorageController> SataCtl;
1065	CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("SATA").raw(),
1066	SataCtl.asOutParam()));
1067
1068	if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
1069	CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
1070	break;
1071	}
1072
1073	case MODIFYVM_SATA: // deprecated
1074	{
1075	if (!RTStrICmp(ValueUnion.psz, "on") \|\| !RTStrICmp(ValueUnion.psz, "enable"))
1076	{
1077	ComPtr<IStorageController> ctl;
1078	CHECK_ERROR(sessionMachine, AddStorageController(Bstr("SATA").raw(),
1079	StorageBus_SATA,
1080	ctl.asOutParam()));
1081	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
1082	}
1083	else if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
1084	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw()));
1085	else
1086	return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
1087	break;
1088	}
1089
1090	case MODIFYVM_SCSIPORT: // deprecated
1091	{
1092	if (!RTStrICmp(ValueUnion.psz, "none"))
1093	{
1094	rc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
1095	GetOptState.uIndex, 0);
1096	if (FAILED(rc))
1097	CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(),
1098	GetOptState.uIndex, 0));
1099	}
1100	else
1101	{
1102	ComPtr<IMedium> hardDisk;
1103	rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1104	AccessMode_ReadWrite, hardDisk,
1105	false /* fForceNewUuidOnOpen */,
1106	false /* fSilent */);
1107	if (FAILED(rc))
1108	break;
1109	if (hardDisk)
1110	{
1111	rc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
1112	GetOptState.uIndex, 0,
1113	DeviceType_HardDisk,
1114	hardDisk);
1115	if (FAILED(rc))
1116	CHECK_ERROR(sessionMachine,
1117	AttachDevice(Bstr("BusLogic").raw(),
1118	GetOptState.uIndex, 0,
1119	DeviceType_HardDisk,
1120	hardDisk));
1121	}
1122	else
1123	rc = E_FAIL;
1124	}
1125	break;
1126	}
1127
1128	case MODIFYVM_SCSITYPE: // deprecated
1129	{
1130	ComPtr<IStorageController> ctl;
1131
1132	if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
1133	{
1134	rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1135	if (FAILED(rc))
1136	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1137
1138	CHECK_ERROR(sessionMachine,
1139	AddStorageController(Bstr("LsiLogic").raw(),
1140	StorageBus_SCSI,
1141	ctl.asOutParam()));
1142
1143	if (SUCCEEDED(rc))
1144	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1145	}
1146	else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
1147	{
1148	rc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
1149	if (FAILED(rc))
1150	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw()));
1151
1152	CHECK_ERROR(sessionMachine,
1153	AddStorageController(Bstr("BusLogic").raw(),
1154	StorageBus_SCSI,
1155	ctl.asOutParam()));
1156
1157	if (SUCCEEDED(rc))
1158	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1159	}
1160	else
1161	return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
1162	break;
1163	}
1164
1165	case MODIFYVM_SCSI: // deprecated
1166	{
1167	if (!RTStrICmp(ValueUnion.psz, "on") \|\| !RTStrICmp(ValueUnion.psz, "enable"))
1168	{
1169	ComPtr<IStorageController> ctl;
1170
1171	CHECK_ERROR(sessionMachine, AddStorageController(Bstr("BusLogic").raw(),
1172	StorageBus_SCSI,
1173	ctl.asOutParam()));
1174	if (SUCCEEDED(rc))
1175	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1176	}
1177	else if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
1178	{
1179	rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1180	if (FAILED(rc))
1181	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1182	}
1183	break;
1184	}
1185
1186	case MODIFYVM_DVDPASSTHROUGH: // deprecated
1187	{
1188	CHECK_ERROR(sessionMachine, PassthroughDevice(Bstr("IDE Controller").raw(),
1189	1, 0,
1190	!RTStrICmp(ValueUnion.psz, "on")));
1191	break;
1192	}
1193
1194	case MODIFYVM_DVD: // deprecated
1195	{
1196	ComPtr<IMedium> dvdMedium;
1197
1198	/* unmount? */
1199	if (!RTStrICmp(ValueUnion.psz, "none"))
1200	{
1201	/* nothing to do, NULL object will cause unmount */
1202	}
1203	/* host drive? */
1204	else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1205	{
1206	ComPtr<IHost> host;
1207	CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1208	rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
1209	dvdMedium.asOutParam());
1210	if (!dvdMedium)
1211	{
1212	/* 2nd try: try with the real name, important on Linux+libhal */
1213	char szPathReal[RTPATH_MAX];
1214	if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
1215	{
1216	errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1217	rc = E_FAIL;
1218	break;
1219	}
1220	rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
1221	dvdMedium.asOutParam());
1222	if (!dvdMedium)
1223	{
1224	errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1225	rc = E_FAIL;
1226	break;
1227	}
1228	}
1229	}
1230	else
1231	{
1232	rc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
1233	AccessMode_ReadOnly, dvdMedium,
1234	false /* fForceNewUuidOnOpen */,
1235	false /* fSilent */);
1236	if (FAILED(rc))
1237	break;
1238	if (!dvdMedium)
1239	{
1240	rc = E_FAIL;
1241	break;
1242	}
1243	}
1244
1245	CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller").raw(),
1246	1, 0,
1247	dvdMedium,
1248	FALSE /* aForce */));
1249	break;
1250	}
1251
1252	case MODIFYVM_FLOPPY: // deprecated
1253	{
1254	ComPtr<IMedium> floppyMedium;
1255	ComPtr<IMediumAttachment> floppyAttachment;
1256	sessionMachine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1257	0, 0, floppyAttachment.asOutParam());
1258
1259	/* disable? */
1260	if (!RTStrICmp(ValueUnion.psz, "disabled"))
1261	{
1262	/* disable the controller */
1263	if (floppyAttachment)
1264	CHECK_ERROR(sessionMachine, DetachDevice(Bstr("Floppy Controller").raw(),
1265	0, 0));
1266	}
1267	else
1268	{
1269	/* enable the controller */
1270	if (!floppyAttachment)
1271	CHECK_ERROR(sessionMachine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1272	0, 0,
1273	DeviceType_Floppy));
1274
1275	/* unmount? */
1276	if ( !RTStrICmp(ValueUnion.psz, "none")
1277	\|\| !RTStrICmp(ValueUnion.psz, "empty")) // deprecated
1278	{
1279	/* nothing to do, NULL object will cause unmount */
1280	}
1281	/* host drive? */
1282	else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1283	{
1284	ComPtr<IHost> host;
1285	CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1286	rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1287	floppyMedium.asOutParam());
1288	if (!floppyMedium)
1289	{
1290	errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
1291	rc = E_FAIL;
1292	break;
1293	}
1294	}
1295	else
1296	{
1297	rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
1298	AccessMode_ReadWrite, floppyMedium,
1299	false /* fForceNewUuidOnOpen */,
1300	false /* fSilent */);
1301	if (FAILED(rc))
1302	break;
1303	if (!floppyMedium)
1304	{
1305	rc = E_FAIL;
1306	break;
1307	}
1308	}
1309	CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller").raw(),
1310	0, 0,
1311	floppyMedium,
1312	FALSE /* aForce */));
1313	}
1314	break;
1315	}
1316
1317	case MODIFYVM_NICTRACEFILE:
1318	{
1319
1320	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1321	break;
1322
1323	ComPtr<INetworkAdapter> nic;
1324	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1325	ASSERT(nic);
1326
1327	CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1328	break;
1329	}
1330
1331	case MODIFYVM_NICTRACE:
1332	{
1333	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1334	break;
1335
1336	ComPtr<INetworkAdapter> nic;
1337	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1338	ASSERT(nic);
1339
1340	CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1341	break;
1342	}
1343
1344	case MODIFYVM_NICPROPERTY:
1345	{
1346	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1347	break;
1348
1349	ComPtr<INetworkAdapter> nic;
1350	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1351	ASSERT(nic);
1352
1353	if (nic)
1354	{
1355	/* Parse 'name=value' */
1356	char *pszProperty = RTStrDup(ValueUnion.psz);
1357	if (pszProperty)
1358	{
1359	char *pDelimiter = strchr(pszProperty, '=');
1360	if (pDelimiter)
1361	{
1362	*pDelimiter = '\0';
1363
1364	Bstr bstrName = pszProperty;
1365	Bstr bstrValue = &pDelimiter[1];
1366	CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw()));
1367	}
1368	else
1369	{
1370	errorArgument("Invalid --nicproperty%d argument '%s'", GetOptState.uIndex, ValueUnion.psz);
1371	rc = E_FAIL;
1372	}
1373	RTStrFree(pszProperty);
1374	}
1375	else
1376	{
1377	RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for --nicproperty%d '%s'\n", GetOptState.uIndex, ValueUnion.psz);
1378	rc = E_FAIL;
1379	}
1380	}
1381	break;
1382	}
1383	case MODIFYVM_NICTYPE:
1384	{
1385	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1386	break;
1387
1388	ComPtr<INetworkAdapter> nic;
1389	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1390	ASSERT(nic);
1391
1392	if (!RTStrICmp(ValueUnion.psz, "Am79C970A"))
1393	{
1394	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1395	}
1396	else if (!RTStrICmp(ValueUnion.psz, "Am79C973"))
1397	{
1398	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1399	}
1400	#ifdef VBOX_WITH_E1000
1401	else if (!RTStrICmp(ValueUnion.psz, "82540EM"))
1402	{
1403	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1404	}
1405	else if (!RTStrICmp(ValueUnion.psz, "82543GC"))
1406	{
1407	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1408	}
1409	else if (!RTStrICmp(ValueUnion.psz, "82545EM"))
1410	{
1411	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1412	}
1413	#endif
1414	#ifdef VBOX_WITH_VIRTIO
1415	else if (!RTStrICmp(ValueUnion.psz, "virtio"))
1416	{
1417	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1418	}
1419	#endif /* VBOX_WITH_VIRTIO */
1420	else
1421	{
1422	errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1423	rc = E_FAIL;
1424	}
1425	break;
1426	}
1427
1428	case MODIFYVM_NICSPEED:
1429	{
1430	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1431	break;
1432
1433	ComPtr<INetworkAdapter> nic;
1434	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1435	ASSERT(nic);
1436
1437	CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1438	break;
1439	}
1440
1441	case MODIFYVM_NICBOOTPRIO:
1442	{
1443	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1444	break;
1445
1446	ComPtr<INetworkAdapter> nic;
1447	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1448	ASSERT(nic);
1449
1450	/* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1451	* to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1452	* 0 for the default lowest priority).
1453	*/
1454	if (ValueUnion.u32 > 4)
1455	{
1456	errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex);
1457	rc = E_FAIL;
1458	}
1459	else
1460	{
1461	CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1462	}
1463	break;
1464	}
1465
1466	case MODIFYVM_NICPROMISC:
1467	{
1468	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1469	if (!RTStrICmp(ValueUnion.psz, "deny"))
1470	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1471	else if ( !RTStrICmp(ValueUnion.psz, "allow-vms")
1472	\|\| !RTStrICmp(ValueUnion.psz, "allow-network"))
1473	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1474	else if (!RTStrICmp(ValueUnion.psz, "allow-all"))
1475	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1476	else
1477	{
1478	errorArgument("Unknown promiscuous mode policy '%s'", ValueUnion.psz);
1479	rc = E_INVALIDARG;
1480	break;
1481	}
1482
1483	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1484	break;
1485
1486	ComPtr<INetworkAdapter> nic;
1487	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1488	ASSERT(nic);
1489
1490	CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1491	break;
1492	}
1493
1494	case MODIFYVM_NICBWGROUP:
1495	{
1496	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1497	break;
1498
1499	ComPtr<INetworkAdapter> nic;
1500	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1501	ASSERT(nic);
1502
1503	if (!RTStrICmp(ValueUnion.psz, "none"))
1504	{
1505	/* Just remove the bandwidth group. */
1506	CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL));
1507	}
1508	else
1509	{
1510	ComPtr<IBandwidthControl> bwCtrl;
1511	ComPtr<IBandwidthGroup> bwGroup;
1512
1513	CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1514
1515	if (SUCCEEDED(rc))
1516	{
1517	CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
1518	if (SUCCEEDED(rc))
1519	{
1520	CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
1521	}
1522	}
1523	}
1524	break;
1525	}
1526
1527	case MODIFYVM_NIC:
1528	{
1529	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1530	break;
1531
1532	ComPtr<INetworkAdapter> nic;
1533	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1534	ASSERT(nic);
1535
1536	if (!RTStrICmp(ValueUnion.psz, "none"))
1537	{
1538	CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1539	}
1540	else if (!RTStrICmp(ValueUnion.psz, "null"))
1541	{
1542	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1543	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
1544	}
1545	else if (!RTStrICmp(ValueUnion.psz, "nat"))
1546	{
1547	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1548	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
1549	}
1550	else if ( !RTStrICmp(ValueUnion.psz, "bridged")
1551	\|\| !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1552	{
1553	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1554	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
1555	}
1556	else if (!RTStrICmp(ValueUnion.psz, "intnet"))
1557	{
1558	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1559	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
1560	}
1561	else if (!RTStrICmp(ValueUnion.psz, "hostonly"))
1562	{
1563
1564	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1565	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
1566	}
1567	else if (!RTStrICmp(ValueUnion.psz, "generic"))
1568	{
1569
1570	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1571	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
1572	}
1573	else if (!RTStrICmp(ValueUnion.psz, "natnetwork"))
1574	{
1575
1576	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1577	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork));
1578	}
1579	else
1580	{
1581	errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1582	rc = E_FAIL;
1583	}
1584	break;
1585	}
1586
1587	case MODIFYVM_CABLECONNECTED:
1588	{
1589	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1590	break;
1591
1592	ComPtr<INetworkAdapter> nic;
1593	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1594	ASSERT(nic);
1595
1596	CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1597	break;
1598	}
1599
1600	case MODIFYVM_BRIDGEADAPTER:
1601	{
1602	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1603	break;
1604
1605	ComPtr<INetworkAdapter> nic;
1606	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1607	ASSERT(nic);
1608
1609	/* remove it? */
1610	if (!RTStrICmp(ValueUnion.psz, "none"))
1611	{
1612	CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
1613	}
1614	else
1615	{
1616	CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
1617	}
1618	break;
1619	}
1620
1621	case MODIFYVM_HOSTONLYADAPTER:
1622	{
1623	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1624	break;
1625
1626	ComPtr<INetworkAdapter> nic;
1627	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1628	ASSERT(nic);
1629
1630	/* remove it? */
1631	if (!RTStrICmp(ValueUnion.psz, "none"))
1632	{
1633	CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
1634	}
1635	else
1636	{
1637	CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
1638	}
1639	break;
1640	}
1641
1642	case MODIFYVM_INTNET:
1643	{
1644	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1645	break;
1646
1647	ComPtr<INetworkAdapter> nic;
1648	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1649	ASSERT(nic);
1650
1651	/* remove it? */
1652	if (!RTStrICmp(ValueUnion.psz, "none"))
1653	{
1654	CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
1655	}
1656	else
1657	{
1658	CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
1659	}
1660	break;
1661	}
1662
1663	case MODIFYVM_GENERICDRV:
1664	{
1665	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1666	break;
1667
1668	ComPtr<INetworkAdapter> nic;
1669	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1670	ASSERT(nic);
1671
1672	CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw()));
1673	break;
1674	}
1675
1676	case MODIFYVM_NATNETWORKNAME:
1677	{
1678	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1679	break;
1680
1681	ComPtr<INetworkAdapter> nic;
1682	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1683	ASSERT(nic);
1684
1685	CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw()));
1686	break;
1687	}
1688
1689	case MODIFYVM_NATNET:
1690	{
1691	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1692	break;
1693
1694	ComPtr<INetworkAdapter> nic;
1695	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1696	ASSERT(nic);
1697
1698	ComPtr<INATEngine> engine;
1699	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1700
1701	const char *psz = ValueUnion.psz;
1702	if (!RTStrICmp("default", psz))
1703	psz = "";
1704
1705	CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
1706	break;
1707	}
1708
1709	case MODIFYVM_NATBINDIP:
1710	{
1711	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1712	break;
1713
1714	ComPtr<INetworkAdapter> nic;
1715	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1716	ASSERT(nic);
1717
1718	ComPtr<INATEngine> engine;
1719	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1720
1721	CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
1722	break;
1723	}
1724
1725	#define ITERATE_TO_NEXT_TERM(ch) \
1726	do { \
1727	while (*ch != ',') \
1728	{ \
1729	if (*ch == 0) \
1730	{ \
1731	return errorSyntax(USAGE_MODIFYVM, \
1732	"Missing or Invalid argument to '%s'", \
1733	GetOptState.pDef->pszLong); \
1734	} \
1735	ch++; \
1736	} \
1737	*ch = '\0'; \
1738	ch++; \
1739	} while(0)
1740
1741	case MODIFYVM_NATSETTINGS:
1742	{
1743	ComPtr<INetworkAdapter> nic;
1744	ComPtr<INATEngine> engine;
1745	char *strMtu;
1746	char *strSockSnd;
1747	char *strSockRcv;
1748	char *strTcpSnd;
1749	char *strTcpRcv;
1750	char *strRaw = RTStrDup(ValueUnion.psz);
1751	char *ch = strRaw;
1752	strMtu = RTStrStrip(ch);
1753	ITERATE_TO_NEXT_TERM(ch);
1754	strSockSnd = RTStrStrip(ch);
1755	ITERATE_TO_NEXT_TERM(ch);
1756	strSockRcv = RTStrStrip(ch);
1757	ITERATE_TO_NEXT_TERM(ch);
1758	strTcpSnd = RTStrStrip(ch);
1759	ITERATE_TO_NEXT_TERM(ch);
1760	strTcpRcv = RTStrStrip(ch);
1761
1762	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1763	break;
1764
1765	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1766	ASSERT(nic);
1767
1768	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1769	CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
1770	RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1771	break;
1772	}
1773
1774
1775	case MODIFYVM_NATPF:
1776	{
1777	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1778	break;
1779
1780	ComPtr<INetworkAdapter> nic;
1781	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1782	ASSERT(nic);
1783
1784	ComPtr<INATEngine> engine;
1785	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1786
1787	/* format name:proto:hostip:hostport:guestip:guestport*/
1788	if (RTStrCmp(ValueUnion.psz, "delete") != 0)
1789	{
1790	char *strName;
1791	char *strProto;
1792	char *strHostIp;
1793	char *strHostPort;
1794	char *strGuestIp;
1795	char *strGuestPort;
1796	char *strRaw = RTStrDup(ValueUnion.psz);
1797	char *ch = strRaw;
1798	strName = RTStrStrip(ch);
1799	ITERATE_TO_NEXT_TERM(ch);
1800	strProto = RTStrStrip(ch);
1801	ITERATE_TO_NEXT_TERM(ch);
1802	strHostIp = RTStrStrip(ch);
1803	ITERATE_TO_NEXT_TERM(ch);
1804	strHostPort = RTStrStrip(ch);
1805	ITERATE_TO_NEXT_TERM(ch);
1806	strGuestIp = RTStrStrip(ch);
1807	ITERATE_TO_NEXT_TERM(ch);
1808	strGuestPort = RTStrStrip(ch);
1809	NATProtocol_T proto;
1810	if (RTStrICmp(strProto, "udp") == 0)
1811	proto = NATProtocol_UDP;
1812	else if (RTStrICmp(strProto, "tcp") == 0)
1813	proto = NATProtocol_TCP;
1814	else
1815	{
1816	errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1817	rc = E_FAIL;
1818	break;
1819	}
1820	CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
1821	Bstr(strHostIp).raw(),
1822	RTStrToUInt16(strHostPort),
1823	Bstr(strGuestIp).raw(),
1824	RTStrToUInt16(strGuestPort)));
1825	}
1826	else
1827	{
1828	/* delete NAT Rule operation */
1829	int vrc;
1830	vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1831	if (RT_FAILURE(vrc))
1832	return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
1833	CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
1834	}
1835	break;
1836	}
1837	#undef ITERATE_TO_NEXT_TERM
1838	case MODIFYVM_NATALIASMODE:
1839	{
1840	ComPtr<INetworkAdapter> nic;
1841	ComPtr<INATEngine> engine;
1842	uint32_t aliasMode = 0;
1843
1844	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1845	ASSERT(nic);
1846
1847	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1848	if (RTStrCmp(ValueUnion.psz, "default") == 0)
1849	aliasMode = 0;
1850	else
1851	{
1852	char token = (char )ValueUnion.psz;
1853	while (token)
1854	{
1855	if (RTStrNCmp(token, RT_STR_TUPLE("log")) == 0)
1856	aliasMode \|= NATAliasMode_AliasLog;
1857	else if (RTStrNCmp(token, RT_STR_TUPLE("proxyonly")) == 0)
1858	aliasMode \|= NATAliasMode_AliasProxyOnly;
1859	else if (RTStrNCmp(token, RT_STR_TUPLE("sameports")) == 0)
1860	aliasMode \|= NATAliasMode_AliasUseSamePorts;
1861	token = RTStrStr(token, ",");
1862	if (token == NULL)
1863	break;
1864	token++;
1865	}
1866	}
1867	CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
1868	break;
1869	}
1870
1871	case MODIFYVM_NATTFTPPREFIX:
1872	{
1873	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1874	break;
1875
1876	ComPtr<INetworkAdapter> nic;
1877	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1878	ASSERT(nic);
1879
1880	ComPtr<INATEngine> engine;
1881	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1882
1883	CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
1884	break;
1885	}
1886
1887	case MODIFYVM_NATTFTPFILE:
1888	{
1889	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1890	break;
1891
1892	ComPtr<INetworkAdapter> nic;
1893	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1894	ASSERT(nic);
1895
1896	ComPtr<INATEngine> engine;
1897	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1898
1899	CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
1900	break;
1901	}
1902
1903	case MODIFYVM_NATTFTPSERVER:
1904	{
1905	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1906	break;
1907
1908	ComPtr<INetworkAdapter> nic;
1909	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1910	ASSERT(nic);
1911
1912	ComPtr<INATEngine> engine;
1913	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1914
1915	CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
1916	break;
1917	}
1918	case MODIFYVM_NATDNSPASSDOMAIN:
1919	{
1920	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1921	break;
1922
1923	ComPtr<INetworkAdapter> nic;
1924	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1925	ASSERT(nic);
1926
1927	ComPtr<INATEngine> engine;
1928	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1929
1930	CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
1931	break;
1932	}
1933
1934	case MODIFYVM_NATDNSPROXY:
1935	{
1936	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1937	break;
1938
1939	ComPtr<INetworkAdapter> nic;
1940	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1941	ASSERT(nic);
1942
1943	ComPtr<INATEngine> engine;
1944	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1945
1946	CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
1947	break;
1948	}
1949
1950	case MODIFYVM_NATDNSHOSTRESOLVER:
1951	{
1952	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1953	break;
1954
1955	ComPtr<INetworkAdapter> nic;
1956	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1957	ASSERT(nic);
1958
1959	ComPtr<INATEngine> engine;
1960	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1961
1962	CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
1963	break;
1964	}
1965	case MODIFYVM_MACADDRESS:
1966	{
1967	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1968	break;
1969
1970	ComPtr<INetworkAdapter> nic;
1971	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1972	ASSERT(nic);
1973
1974	/* generate one? */
1975	if (!RTStrICmp(ValueUnion.psz, "auto"))
1976	{
1977	CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
1978	}
1979	else
1980	{
1981	CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
1982	}
1983	break;
1984	}
1985
1986	case MODIFYVM_HIDPTR:
1987	{
1988	bool fEnableUsb = false;
1989	if (!RTStrICmp(ValueUnion.psz, "ps2"))
1990	{
1991	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
1992	}
1993	else if (!RTStrICmp(ValueUnion.psz, "usb"))
1994	{
1995	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
1996	if (SUCCEEDED(rc))
1997	fEnableUsb = true;
1998	}
1999	else if (!RTStrICmp(ValueUnion.psz, "usbtablet"))
2000	{
2001	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
2002	if (SUCCEEDED(rc))
2003	fEnableUsb = true;
2004	}
2005	else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch"))
2006	{
2007	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
2008	if (SUCCEEDED(rc))
2009	fEnableUsb = true;
2010	}
2011	else
2012	{
2013	errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
2014	rc = E_FAIL;
2015	}
2016	if (fEnableUsb)
2017	{
2018	/* Make sure either the OHCI or xHCI controller is enabled. */
2019	ULONG cOhciCtrls = 0;
2020	ULONG cXhciCtrls = 0;
2021	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2022	if (SUCCEEDED(rc)) {
2023	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2024	if ( SUCCEEDED(rc)
2025	&& cOhciCtrls + cXhciCtrls == 0)
2026	{
2027	/* If there's nothing, enable OHCI (always available). */
2028	ComPtr<IUSBController> UsbCtl;
2029	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2030	UsbCtl.asOutParam()));
2031	}
2032	}
2033	}
2034	break;
2035	}
2036
2037	case MODIFYVM_HIDKBD:
2038	{
2039	bool fEnableUsb = false;
2040	if (!RTStrICmp(ValueUnion.psz, "ps2"))
2041	{
2042	CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
2043	}
2044	else if (!RTStrICmp(ValueUnion.psz, "usb"))
2045	{
2046	CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
2047	if (SUCCEEDED(rc))
2048	fEnableUsb = true;
2049	}
2050	else
2051	{
2052	errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
2053	rc = E_FAIL;
2054	}
2055	if (fEnableUsb)
2056	{
2057	/* Make sure either the OHCI or xHCI controller is enabled. */
2058	ULONG cOhciCtrls = 0;
2059	ULONG cXhciCtrls = 0;
2060	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2061	if (SUCCEEDED(rc)) {
2062	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2063	if ( SUCCEEDED(rc)
2064	&& cOhciCtrls + cXhciCtrls == 0)
2065	{
2066	/* If there's nothing, enable OHCI (always available). */
2067	ComPtr<IUSBController> UsbCtl;
2068	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2069	UsbCtl.asOutParam()));
2070	}
2071	}
2072	}
2073	break;
2074	}
2075
2076	case MODIFYVM_UARTMODE:
2077	{
2078	ComPtr<ISerialPort> uart;
2079
2080	CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2081	ASSERT(uart);
2082
2083	if (!RTStrICmp(ValueUnion.psz, "disconnected"))
2084	{
2085	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2086	}
2087	else if ( !RTStrICmp(ValueUnion.psz, "server")
2088	\|\| !RTStrICmp(ValueUnion.psz, "client")
2089	\|\| !RTStrICmp(ValueUnion.psz, "tcpserver")
2090	\|\| !RTStrICmp(ValueUnion.psz, "tcpclient")
2091	\|\| !RTStrICmp(ValueUnion.psz, "file"))
2092	{
2093	const char *pszMode = ValueUnion.psz;
2094
2095	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2096	if (RT_FAILURE(vrc))
2097	return errorSyntax(USAGE_MODIFYVM,
2098	"Missing or Invalid argument to '%s'",
2099	GetOptState.pDef->pszLong);
2100
2101	CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2102
2103	if (!RTStrICmp(pszMode, "server"))
2104	{
2105	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2106	CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2107	}
2108	else if (!RTStrICmp(pszMode, "client"))
2109	{
2110	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2111	CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2112	}
2113	else if (!RTStrICmp(pszMode, "tcpserver"))
2114	{
2115	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2116	CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2117	}
2118	else if (!RTStrICmp(pszMode, "tcpclient"))
2119	{
2120	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2121	CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2122	}
2123	else if (!RTStrICmp(pszMode, "file"))
2124	{
2125	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
2126	}
2127	}
2128	else
2129	{
2130	CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2131	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
2132	}
2133	break;
2134	}
2135
2136	case MODIFYVM_UART:
2137	{
2138	ComPtr<ISerialPort> uart;
2139
2140	CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2141	ASSERT(uart);
2142
2143	if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
2144	CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
2145	else
2146	{
2147	const char *pszIOBase = ValueUnion.psz;
2148	uint32_t uVal = 0;
2149
2150	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
2151	if (RT_FAILURE(vrc))
2152	return errorSyntax(USAGE_MODIFYVM,
2153	"Missing or Invalid argument to '%s'",
2154	GetOptState.pDef->pszLong);
2155
2156	CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
2157
2158	vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2159	if (vrc != VINF_SUCCESS \|\| uVal == 0)
2160	return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
2161	CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
2162
2163	CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
2164	}
2165	break;
2166	}
2167
2168	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
2169	case MODIFYVM_LPTMODE:
2170	{
2171	ComPtr<IParallelPort> lpt;
2172
2173	CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2174	ASSERT(lpt);
2175
2176	CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2177	break;
2178	}
2179
2180	case MODIFYVM_LPT:
2181	{
2182	ComPtr<IParallelPort> lpt;
2183
2184	CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2185	ASSERT(lpt);
2186
2187	if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
2188	CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE));
2189	else
2190	{
2191	const char *pszIOBase = ValueUnion.psz;
2192	uint32_t uVal = 0;
2193
2194	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT;
2195	if (RT_FAILURE(vrc))
2196	return errorSyntax(USAGE_MODIFYVM,
2197	"Missing or Invalid argument to '%s'",
2198	GetOptState.pDef->pszLong);
2199
2200	CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32));
2201
2202	vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2203	if (vrc != VINF_SUCCESS \|\| uVal == 0)
2204	return errorArgument("Error parsing LPT I/O base '%s'", pszIOBase);
2205	CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
2206
2207	CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE));
2208	}
2209	break;
2210	}
2211	#endif
2212
2213	case MODIFYVM_GUESTMEMORYBALLOON:
2214	{
2215	CHECK_ERROR(sessionMachine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
2216	break;
2217	}
2218
2219	case MODIFYVM_AUDIOCONTROLLER:
2220	{
2221	ComPtr<IAudioAdapter> audioAdapter;
2222	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2223	ASSERT(audioAdapter);
2224
2225	if (!RTStrICmp(ValueUnion.psz, "sb16"))
2226	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
2227	else if (!RTStrICmp(ValueUnion.psz, "ac97"))
2228	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
2229	else if (!RTStrICmp(ValueUnion.psz, "hda"))
2230	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
2231	else
2232	{
2233	errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
2234	rc = E_FAIL;
2235	}
2236	break;
2237	}
2238
2239	case MODIFYVM_AUDIOCODEC:
2240	{
2241	ComPtr<IAudioAdapter> audioAdapter;
2242	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2243	ASSERT(audioAdapter);
2244
2245	if (!RTStrICmp(ValueUnion.psz, "sb16"))
2246	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_SB16));
2247	else if (!RTStrICmp(ValueUnion.psz, "stac9700"))
2248	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9700));
2249	else if (!RTStrICmp(ValueUnion.psz, "ad1980"))
2250	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_AD1980));
2251	else if (!RTStrICmp(ValueUnion.psz, "stac9221"))
2252	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9221));
2253	else
2254	{
2255	errorArgument("Invalid --audiocodec argument '%s'", ValueUnion.psz);
2256	rc = E_FAIL;
2257	}
2258	break;
2259	}
2260
2261	case MODIFYVM_AUDIO:
2262	{
2263	ComPtr<IAudioAdapter> audioAdapter;
2264	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2265	ASSERT(audioAdapter);
2266
2267	/* disable? */
2268	if (!RTStrICmp(ValueUnion.psz, "none"))
2269	{
2270	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
2271	}
2272	else if (!RTStrICmp(ValueUnion.psz, "null"))
2273	{
2274	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
2275	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2276	}
2277	#ifdef RT_OS_WINDOWS
2278	#ifdef VBOX_WITH_WINMM
2279	else if (!RTStrICmp(ValueUnion.psz, "winmm"))
2280	{
2281	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
2282	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2283	}
2284	#endif
2285	else if (!RTStrICmp(ValueUnion.psz, "dsound"))
2286	{
2287	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
2288	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2289	}
2290	#endif /* RT_OS_WINDOWS */
2291	#ifdef VBOX_WITH_AUDIO_OSS
2292	else if (!RTStrICmp(ValueUnion.psz, "oss"))
2293	{
2294	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2295	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2296	}
2297	#endif
2298	#ifdef VBOX_WITH_AUDIO_ALSA
2299	else if (!RTStrICmp(ValueUnion.psz, "alsa"))
2300	{
2301	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
2302	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2303	}
2304	#endif
2305	#ifdef VBOX_WITH_AUDIO_PULSE
2306	else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2307	{
2308	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2309	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2310	}
2311	#endif
2312	#ifdef RT_OS_DARWIN
2313	else if (!RTStrICmp(ValueUnion.psz, "coreaudio"))
2314	{
2315	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
2316	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2317	}
2318	#endif /* !RT_OS_DARWIN */
2319	else
2320	{
2321	errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
2322	rc = E_FAIL;
2323	}
2324	break;
2325	}
2326
2327	case MODIFYVM_CLIPBOARD:
2328	{
2329	ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */
2330	if (!RTStrICmp(ValueUnion.psz, "disabled"))
2331	mode = ClipboardMode_Disabled;
2332	else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2333	mode = ClipboardMode_HostToGuest;
2334	else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2335	mode = ClipboardMode_GuestToHost;
2336	else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2337	mode = ClipboardMode_Bidirectional;
2338	else
2339	{
2340	errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
2341	rc = E_FAIL;
2342	}
2343	if (SUCCEEDED(rc))
2344	{
2345	CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode));
2346	}
2347	break;
2348	}
2349
2350	case MODIFYVM_DRAGANDDROP:
2351	{
2352	DnDMode_T mode = DnDMode_Disabled; /* Shut up MSC */
2353	if (!RTStrICmp(ValueUnion.psz, "disabled"))
2354	mode = DnDMode_Disabled;
2355	else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2356	mode = DnDMode_HostToGuest;
2357	else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2358	mode = DnDMode_GuestToHost;
2359	else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2360	mode = DnDMode_Bidirectional;
2361	else
2362	{
2363	errorArgument("Invalid --draganddrop argument '%s'", ValueUnion.psz);
2364	rc = E_FAIL;
2365	}
2366	if (SUCCEEDED(rc))
2367	{
2368	CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode));
2369	}
2370	break;
2371	}
2372
2373	case MODIFYVM_VRDE_EXTPACK:
2374	{
2375	ComPtr<IVRDEServer> vrdeServer;
2376	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2377	ASSERT(vrdeServer);
2378
2379	if (vrdeServer)
2380	{
2381	if (RTStrICmp(ValueUnion.psz, "default") != 0)
2382	{
2383	Bstr bstr(ValueUnion.psz);
2384	CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
2385	}
2386	else
2387	CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
2388	}
2389	break;
2390	}
2391
2392	case MODIFYVM_VRDEPROPERTY:
2393	{
2394	ComPtr<IVRDEServer> vrdeServer;
2395	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2396	ASSERT(vrdeServer);
2397
2398	if (vrdeServer)
2399	{
2400	/* Parse 'name=value' */
2401	char *pszProperty = RTStrDup(ValueUnion.psz);
2402	if (pszProperty)
2403	{
2404	char *pDelimiter = strchr(pszProperty, '=');
2405	if (pDelimiter)
2406	{
2407	*pDelimiter = '\0';
2408
2409	Bstr bstrName = pszProperty;
2410	Bstr bstrValue = &pDelimiter[1];
2411	CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
2412	}
2413	else
2414	{
2415	RTStrFree(pszProperty);
2416
2417	errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz);
2418	rc = E_FAIL;
2419	break;
2420	}
2421	RTStrFree(pszProperty);
2422	}
2423	else
2424	{
2425	RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", ValueUnion.psz);
2426	rc = E_FAIL;
2427	}
2428	}
2429	break;
2430	}
2431
2432	case MODIFYVM_VRDPPORT:
2433	vrdeWarningDeprecatedOption("port");
2434	/* fall thru */
2435
2436	case MODIFYVM_VRDEPORT:
2437	{
2438	ComPtr<IVRDEServer> vrdeServer;
2439	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2440	ASSERT(vrdeServer);
2441
2442	if (!RTStrICmp(ValueUnion.psz, "default"))
2443	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
2444	else
2445	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
2446	break;
2447	}
2448
2449	case MODIFYVM_VRDPADDRESS:
2450	vrdeWarningDeprecatedOption("address");
2451	/* fall thru */
2452
2453	case MODIFYVM_VRDEADDRESS:
2454	{
2455	ComPtr<IVRDEServer> vrdeServer;
2456	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2457	ASSERT(vrdeServer);
2458
2459	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw()));
2460	break;
2461	}
2462
2463	case MODIFYVM_VRDPAUTHTYPE:
2464	vrdeWarningDeprecatedOption("authtype");
2465	/* fall thru */
2466	case MODIFYVM_VRDEAUTHTYPE:
2467	{
2468	ComPtr<IVRDEServer> vrdeServer;
2469	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2470	ASSERT(vrdeServer);
2471
2472	if (!RTStrICmp(ValueUnion.psz, "null"))
2473	{
2474	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
2475	}
2476	else if (!RTStrICmp(ValueUnion.psz, "external"))
2477	{
2478	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
2479	}
2480	else if (!RTStrICmp(ValueUnion.psz, "guest"))
2481	{
2482	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
2483	}
2484	else
2485	{
2486	errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz);
2487	rc = E_FAIL;
2488	}
2489	break;
2490	}
2491
2492	case MODIFYVM_VRDEAUTHLIBRARY:
2493	{
2494	ComPtr<IVRDEServer> vrdeServer;
2495	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2496	ASSERT(vrdeServer);
2497
2498	if (vrdeServer)
2499	{
2500	if (RTStrICmp(ValueUnion.psz, "default") != 0)
2501	{
2502	Bstr bstr(ValueUnion.psz);
2503	CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw()));
2504	}
2505	else
2506	CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
2507	}
2508	break;
2509	}
2510
2511	case MODIFYVM_VRDPMULTICON:
2512	vrdeWarningDeprecatedOption("multicon");
2513	/* fall thru */
2514	case MODIFYVM_VRDEMULTICON:
2515	{
2516	ComPtr<IVRDEServer> vrdeServer;
2517	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2518	ASSERT(vrdeServer);
2519
2520	CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
2521	break;
2522	}
2523
2524	case MODIFYVM_VRDPREUSECON:
2525	vrdeWarningDeprecatedOption("reusecon");
2526	/* fall thru */
2527	case MODIFYVM_VRDEREUSECON:
2528	{
2529	ComPtr<IVRDEServer> vrdeServer;
2530	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2531	ASSERT(vrdeServer);
2532
2533	CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
2534	break;
2535	}
2536
2537	case MODIFYVM_VRDPVIDEOCHANNEL:
2538	vrdeWarningDeprecatedOption("videochannel");
2539	/* fall thru */
2540	case MODIFYVM_VRDEVIDEOCHANNEL:
2541	{
2542	ComPtr<IVRDEServer> vrdeServer;
2543	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2544	ASSERT(vrdeServer);
2545
2546	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
2547	ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
2548	break;
2549	}
2550
2551	case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
2552	vrdeWarningDeprecatedOption("videochannelquality");
2553	/* fall thru */
2554	case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
2555	{
2556	ComPtr<IVRDEServer> vrdeServer;
2557	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2558	ASSERT(vrdeServer);
2559
2560	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
2561	Bstr(ValueUnion.psz).raw()));
2562	break;
2563	}
2564
2565	case MODIFYVM_VRDP:
2566	vrdeWarningDeprecatedOption("");
2567	/* fall thru */
2568	case MODIFYVM_VRDE:
2569	{
2570	ComPtr<IVRDEServer> vrdeServer;
2571	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2572	ASSERT(vrdeServer);
2573
2574	CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
2575	break;
2576	}
2577
2578	case MODIFYVM_USBRENAME:
2579	{
2580	const char *pszName = ValueUnion.psz;
2581	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2582	if (RT_FAILURE(vrc))
2583	return errorSyntax(USAGE_MODIFYVM,
2584	"Missing or Invalid argument to '%s'",
2585	GetOptState.pDef->pszLong);
2586	const char *pszNewName = ValueUnion.psz;
2587
2588	SafeIfaceArray<IUSBController> ctrls;
2589	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2590	bool fRenamed = false;
2591	for (size_t i = 0; i < ctrls.size(); i++)
2592	{
2593	ComPtr<IUSBController> pCtrl = ctrls[i];
2594	Bstr bstrName;
2595	CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam()));
2596	if (bstrName == pszName)
2597	{
2598	bstrName = pszNewName;
2599	CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw()));
2600	fRenamed = true;
2601	}
2602	}
2603	if (!fRenamed)
2604	{
2605	errorArgument("Invalid --usbrename parameters, nothing renamed");
2606	rc = E_FAIL;
2607	}
2608	break;
2609	}
2610
2611	case MODIFYVM_USBXHCI:
2612	{
2613	ULONG cXhciCtrls = 0;
2614	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2615	if (SUCCEEDED(rc))
2616	{
2617	if (!cXhciCtrls && ValueUnion.f)
2618	{
2619	ComPtr<IUSBController> UsbCtl;
2620	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI,
2621	UsbCtl.asOutParam()));
2622	}
2623	else if (cXhciCtrls && !ValueUnion.f)
2624	{
2625	SafeIfaceArray<IUSBController> ctrls;
2626	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2627	for (size_t i = 0; i < ctrls.size(); i++)
2628	{
2629	ComPtr<IUSBController> pCtrl = ctrls[i];
2630	USBControllerType_T enmType;
2631	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2632	if (enmType == USBControllerType_XHCI)
2633	{
2634	Bstr ctrlName;
2635	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2636	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2637	}
2638	}
2639	}
2640	}
2641	break;
2642	}
2643
2644	case MODIFYVM_USBEHCI:
2645	{
2646	ULONG cEhciCtrls = 0;
2647	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
2648	if (SUCCEEDED(rc))
2649	{
2650	if (!cEhciCtrls && ValueUnion.f)
2651	{
2652	ComPtr<IUSBController> UsbCtl;
2653	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
2654	UsbCtl.asOutParam()));
2655	}
2656	else if (cEhciCtrls && !ValueUnion.f)
2657	{
2658	SafeIfaceArray<IUSBController> ctrls;
2659	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2660	for (size_t i = 0; i < ctrls.size(); i++)
2661	{
2662	ComPtr<IUSBController> pCtrl = ctrls[i];
2663	USBControllerType_T enmType;
2664	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2665	if (enmType == USBControllerType_EHCI)
2666	{
2667	Bstr ctrlName;
2668	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2669	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2670	}
2671	}
2672	}
2673	}
2674	break;
2675	}
2676
2677	case MODIFYVM_USB:
2678	{
2679	ULONG cOhciCtrls = 0;
2680	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2681	if (SUCCEEDED(rc))
2682	{
2683	if (!cOhciCtrls && ValueUnion.f)
2684	{
2685	ComPtr<IUSBController> UsbCtl;
2686	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2687	UsbCtl.asOutParam()));
2688	}
2689	else if (cOhciCtrls && !ValueUnion.f)
2690	{
2691	SafeIfaceArray<IUSBController> ctrls;
2692	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2693	for (size_t i = 0; i < ctrls.size(); i++)
2694	{
2695	ComPtr<IUSBController> pCtrl = ctrls[i];
2696	USBControllerType_T enmType;
2697	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2698	if (enmType == USBControllerType_OHCI)
2699	{
2700	Bstr ctrlName;
2701	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2702	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2703	}
2704	}
2705	}
2706	}
2707	break;
2708	}
2709
2710	case MODIFYVM_SNAPSHOTFOLDER:
2711	{
2712	if (!RTStrICmp(ValueUnion.psz, "default"))
2713	CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr().raw()));
2714	else
2715	CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
2716	break;
2717	}
2718
2719	case MODIFYVM_TELEPORTER_ENABLED:
2720	{
2721	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
2722	break;
2723	}
2724
2725	case MODIFYVM_TELEPORTER_PORT:
2726	{
2727	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPort)(ValueUnion.u32));
2728	break;
2729	}
2730
2731	case MODIFYVM_TELEPORTER_ADDRESS:
2732	{
2733	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
2734	break;
2735	}
2736
2737	case MODIFYVM_TELEPORTER_PASSWORD:
2738	{
2739	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
2740	break;
2741	}
2742
2743	case MODIFYVM_TELEPORTER_PASSWORD_FILE:
2744	{
2745	Utf8Str password;
2746	RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
2747	if (rcExit != RTEXITCODE_SUCCESS)
2748	rc = E_FAIL;
2749	else
2750	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
2751	break;
2752	}
2753
2754	case MODIFYVM_TRACING_ENABLED:
2755	{
2756	CHECK_ERROR(sessionMachine, COMSETTER(TracingEnabled)(ValueUnion.f));
2757	break;
2758	}
2759
2760	case MODIFYVM_TRACING_CONFIG:
2761	{
2762	CHECK_ERROR(sessionMachine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
2763	break;
2764	}
2765
2766	case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
2767	{
2768	CHECK_ERROR(sessionMachine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
2769	break;
2770	}
2771
2772	case MODIFYVM_FAULT_TOLERANCE:
2773	{
2774	if (!RTStrICmp(ValueUnion.psz, "master"))
2775	{
2776	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Master)));
2777	}
2778	else
2779	if (!RTStrICmp(ValueUnion.psz, "standby"))
2780	{
2781	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Standby)));
2782	}
2783	else
2784	{
2785	errorArgument("Invalid --faulttolerance argument '%s'", ValueUnion.psz);
2786	rc = E_FAIL;
2787	}
2788	break;
2789	}
2790
2791	case MODIFYVM_FAULT_TOLERANCE_ADDRESS:
2792	{
2793	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
2794	break;
2795	}
2796
2797	case MODIFYVM_FAULT_TOLERANCE_PORT:
2798	{
2799	CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePort)(ValueUnion.u32));
2800	break;
2801	}
2802
2803	case MODIFYVM_FAULT_TOLERANCE_PASSWORD:
2804	{
2805	CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
2806	break;
2807	}
2808
2809	case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL:
2810	{
2811	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32));
2812	break;
2813	}
2814
2815	case MODIFYVM_HARDWARE_UUID:
2816	{
2817	CHECK_ERROR(sessionMachine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
2818	break;
2819	}
2820
2821	case MODIFYVM_HPET:
2822	{
2823	CHECK_ERROR(sessionMachine, COMSETTER(HPETEnabled)(ValueUnion.f));
2824	break;
2825	}
2826
2827	case MODIFYVM_IOCACHE:
2828	{
2829	CHECK_ERROR(sessionMachine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
2830	break;
2831	}
2832
2833	case MODIFYVM_IOCACHESIZE:
2834	{
2835	CHECK_ERROR(sessionMachine, COMSETTER(IOCacheSize)(ValueUnion.u32));
2836	break;
2837	}
2838
2839	case MODIFYVM_CHIPSET:
2840	{
2841	if (!RTStrICmp(ValueUnion.psz, "piix3"))
2842	{
2843	CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
2844	}
2845	else if (!RTStrICmp(ValueUnion.psz, "ich9"))
2846	{
2847	CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_ICH9));
2848	BOOL fIoApic = FALSE;
2849	CHECK_ERROR(biosSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
2850	if (!fIoApic)
2851	{
2852	RTStrmPrintf(g_pStdErr, "* I/O APIC must be enabled for ICH9, enabling. *\n");
2853	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE));
2854	}
2855	}
2856	else
2857	{
2858	errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz);
2859	rc = E_FAIL;
2860	}
2861	break;
2862	}
2863	#ifdef VBOX_WITH_VIDEOREC
2864	case MODIFYVM_VIDEOCAP:
2865	{
2866	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureEnabled)(ValueUnion.f));
2867	break;
2868	}
2869	case MODIFYVM_VIDEOCAP_SCREENS:
2870	{
2871	ULONG cMonitors = 64;
2872	CHECK_ERROR(sessionMachine, COMGETTER(MonitorCount)(&cMonitors));
2873	com::SafeArray<BOOL> screens(cMonitors);
2874	if (parseScreens(ValueUnion.psz, &screens))
2875	{
2876	errorArgument("Invalid list of screens specified\n");
2877	rc = E_FAIL;
2878	break;
2879	}
2880	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureScreens)(ComSafeArrayAsInParam(screens)));
2881	break;
2882	}
2883	case MODIFYVM_VIDEOCAP_FILENAME:
2884	{
2885	Bstr bstr;
2886	/* empty string will fall through, leaving bstr empty */
2887	if (*ValueUnion.psz)
2888	{
2889	char szVCFileAbs[RTPATH_MAX] = "";
2890	int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs));
2891	if (RT_FAILURE(vrc))
2892	{
2893	errorArgument("Cannot convert filename \"%s\" to absolute path\n", ValueUnion.psz);
2894	rc = E_FAIL;
2895	break;
2896	}
2897	bstr = szVCFileAbs;
2898	}
2899	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureFile)(bstr.raw()));
2900	break;
2901	}
2902	case MODIFYVM_VIDEOCAP_WIDTH:
2903	{
2904	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureWidth)(ValueUnion.u32));
2905	break;
2906	}
2907	case MODIFYVM_VIDEOCAP_HEIGHT:
2908	{
2909	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureHeight)(ValueUnion.u32));
2910	break;
2911	}
2912	case MODIFYVM_VIDEOCAP_RES:
2913	{
2914	uint32_t uWidth = 0;
2915	char *pszNext;
2916	int vrc = RTStrToUInt32Ex(ValueUnion.psz, &pszNext, 0, &uWidth);
2917	if (RT_FAILURE(vrc) \|\| vrc != VWRN_TRAILING_CHARS \|\| !pszNext \|\| *pszNext != 'x')
2918	{
2919	errorArgument("Error parsing geomtry '%s' (expected <width>x<height>)", ValueUnion.psz);
2920	rc = E_FAIL;
2921	break;
2922	}
2923	uint32_t uHeight = 0;
2924	vrc = RTStrToUInt32Ex(pszNext+1, NULL, 0, &uHeight);
2925	if (vrc != VINF_SUCCESS)
2926	{
2927	errorArgument("Error parsing geomtry '%s' (expected <width>x<height>)", ValueUnion.psz);
2928	rc = E_FAIL;
2929	break;
2930	}
2931	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureWidth)(uWidth));
2932	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureHeight)(uHeight));
2933	break;
2934	}
2935	case MODIFYVM_VIDEOCAP_RATE:
2936	{
2937	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureRate)(ValueUnion.u32));
2938	break;
2939	}
2940	case MODIFYVM_VIDEOCAP_FPS:
2941	{
2942	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureFPS)(ValueUnion.u32));
2943	break;
2944	}
2945	case MODIFYVM_VIDEOCAP_MAXTIME:
2946	{
2947	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureMaxTime)(ValueUnion.u32));
2948	break;
2949	}
2950	case MODIFYVM_VIDEOCAP_MAXSIZE:
2951	{
2952	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureMaxFileSize)(ValueUnion.u32));
2953	break;
2954	}
2955	case MODIFYVM_VIDEOCAP_OPTIONS:
2956	{
2957	Bstr bstr(ValueUnion.psz);
2958	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureOptions)(bstr.raw()));
2959	break;
2960	}
2961	#endif
2962	case MODIFYVM_AUTOSTART_ENABLED:
2963	{
2964	CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(ValueUnion.f));
2965	break;
2966	}
2967
2968	case MODIFYVM_AUTOSTART_DELAY:
2969	{
2970	CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(ValueUnion.u32));
2971	break;
2972	}
2973
2974	case MODIFYVM_AUTOSTOP_TYPE:
2975	{
2976	AutostopType_T enmAutostopType = AutostopType_Disabled;
2977
2978	if (!RTStrICmp(ValueUnion.psz, "disabled"))
2979	enmAutostopType = AutostopType_Disabled;
2980	else if (!RTStrICmp(ValueUnion.psz, "savestate"))
2981	enmAutostopType = AutostopType_SaveState;
2982	else if (!RTStrICmp(ValueUnion.psz, "poweroff"))
2983	enmAutostopType = AutostopType_PowerOff;
2984	else if (!RTStrICmp(ValueUnion.psz, "acpishutdown"))
2985	enmAutostopType = AutostopType_AcpiShutdown;
2986	else
2987	{
2988	errorArgument("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)", ValueUnion.psz);
2989	rc = E_FAIL;
2990	}
2991
2992	if (SUCCEEDED(rc))
2993	CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType));
2994	break;
2995	}
2996	#ifdef VBOX_WITH_PCI_PASSTHROUGH
2997	case MODIFYVM_ATTACH_PCI:
2998	{
2999	const char* pAt = strchr(ValueUnion.psz, '@');
3000	int32_t iHostAddr, iGuestAddr;
3001
3002	iHostAddr = parsePci(ValueUnion.psz);
3003	iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
3004
3005	if (iHostAddr == -1 \|\| iGuestAddr == -1)
3006	{
3007	errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz);
3008	rc = E_FAIL;
3009	}
3010	else
3011	{
3012	CHECK_ERROR(sessionMachine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
3013	}
3014
3015	break;
3016	}
3017	case MODIFYVM_DETACH_PCI:
3018	{
3019	int32_t iHostAddr;
3020
3021	iHostAddr = parsePci(ValueUnion.psz);
3022	if (iHostAddr == -1)
3023	{
3024	errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz);
3025	rc = E_FAIL;
3026	}
3027	else
3028	{
3029	CHECK_ERROR(sessionMachine, DetachHostPCIDevice(iHostAddr));
3030	}
3031
3032	break;
3033	}
3034	#endif
3035
3036	#ifdef VBOX_WITH_USB_CARDREADER
3037	case MODIFYVM_USBCARDREADER:
3038	{
3039	CHECK_ERROR(sessionMachine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f));
3040	break;
3041	}
3042	#endif /* VBOX_WITH_USB_CARDREADER */
3043
3044	case MODIFYVM_DEFAULTFRONTEND:
3045	{
3046	Bstr bstr(ValueUnion.psz);
3047	if (bstr == "default")
3048	bstr = Bstr::Empty;
3049	CHECK_ERROR(sessionMachine, COMSETTER(DefaultFrontend)(bstr.raw()));
3050	break;
3051	}
3052
3053	default:
3054	{
3055	errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
3056	rc = E_FAIL;
3057	break;
3058	}
3059	}
3060	}
3061
3062	/* commit changes */
3063	if (SUCCEEDED(rc))
3064	CHECK_ERROR(sessionMachine, SaveSettings());
3065
3066	/* it's important to always close sessions */
3067	a->session->UnlockMachine();
3068
3069	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3070	}
3071
3072	#endif /* !VBOX_ONLY_DOCS */

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

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

Download in other formats: