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@ 76553

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