VBoxManageModifyVM.cpp@ 81156

Last change on this file since 81156 was 81087, checked in by vboxsync, 5 years ago
Main/Machine+BIOSSettings: bare bones NVRAM logic, many parts missing (no snapshot handling, no move VM handling, no remove VM handling). Main/Settings: adaptions to store NVRAM config in the settings file Frontends/VBoxManage: support enabling and showing state
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 135.1 KB

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

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

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

Download in other formats: