VBoxManageModifyVM.cpp@ 33589

Last change on this file since 33589 was 33556, checked in by vboxsync, 14 years ago
VRDE: More API changes for the VRDP server separation.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.4 KB

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

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

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

Download in other formats: