VBoxManageModifyVM.cpp@ 92133

Last change on this file since 92133 was 92133, checked in by vboxsync, 3 years ago
Main,FE/VBoxManage: Allow changing the localhost reachable flag for the NAT attachment type, bugref:9896
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 144.9 KB

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

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

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

Download in other formats: