VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 76366 was 76366, checked in by vboxsync, 5 years ago
include/VBox/com/Guid.h: Don't include iprt/err.h for no good reason. bugref:9344
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 134.2 KB

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

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use