VBoxManageModifyVM.cpp@ 75251

Last change on this file since 75251 was 75251, checked in by vboxsync, 7 years ago
Capturing: Separated capturing settings into new interfaces ICaptureSettings and ICaptureScreenSettings to unload stuff from IMachine; a lot of internal interface / code cleanups. Also see #9286. Work in progress.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 133.9 KB

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

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

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

Download in other formats: