VBoxManageModifyVM.cpp@ 41520

Last change on this file since 41520 was 41371, checked in by vboxsync, 13 years ago
Main,include,VBoxManage: smartcard support: IMachine::EmulatedUSBCardReaderEnabled.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 98.0 KB

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

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

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

Download in other formats: