VBoxManageModifyVM.cpp@ 43023

Last change on this file since 43023 was 43023, checked in by vboxsync, 12 years ago
Legacy IDE Support: eliminating the API support for configuring the legacy IDE support for AHCI. Legacy IDE fields for settings have been preserved
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.1 KB

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

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

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

Download in other formats: