VBoxManageModifyVM.cpp@ 54911

Last change on this file since 54911 was 54911, checked in by vboxsync, 10 years ago
Main: Added paravirt. provider KVM APIs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 116.2 KB

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

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

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

Download in other formats: