VBoxManageModifyVM.cpp@ 37200

Last change on this file since 37200 was 37200, checked in by vboxsync, 14 years ago
API+Frontends: Generic network attachment driver support which obsoletes the special case for VDE. Big API cleanup in the same area. Adapt all frontends to these changes (full implementation in VBoxManage, minimum implementation in GUI).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 92.8 KB

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

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

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

Download in other formats: