VBoxManageModifyVM.cpp@ 41916

Last change on this file since 41916 was 41916, checked in by vboxsync, 13 years ago
Stupid copy and paste bug
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.7 KB

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

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

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

Download in other formats: