VBoxManageModifyVM.cpp@ 28138

Last change on this file since 28138 was 28106, checked in by vboxsync, 15 years ago
Main: Added machinery to query, set and use NIC boot priority.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 80.0 KB

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

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

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

Download in other formats: