VBoxManageModifyVM.cpp@ 70587

最後變更在這個檔案從70587是 70587,由 vboxsync 提交於 7 年前
VBoxManage: Changed vminfo and modifyvm to refer to OHCI instead of USB to reduce user confusion.
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 129.8 KB

行
1	/* $Id: VBoxManageModifyVM.cpp 70587 2018-01-15 12:51:16Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of modifyvm command.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.alldomusa.eu.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	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#ifndef VBOX_ONLY_DOCS
23	#include <VBox/com/com.h>
24	#include <VBox/com/array.h>
25	#include <VBox/com/ErrorInfo.h>
26	#include <VBox/com/errorprint.h>
27	#include <VBox/com/VirtualBox.h>
28	#endif /* !VBOX_ONLY_DOCS */
29
30	#include <iprt/cidr.h>
31	#include <iprt/ctype.h>
32	#include <iprt/file.h>
33	#include <iprt/param.h>
34	#include <iprt/path.h>
35	#include <iprt/stream.h>
36	#include <iprt/string.h>
37	#include <iprt/getopt.h>
38	#include <VBox/log.h>
39	#include "VBoxManage.h"
40
41	#ifndef VBOX_ONLY_DOCS
42	using namespace com;
43	/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
44	#if defined(_MSC_VER)
45	# pragma optimize("g", off)
46	# if _MSC_VER < RT_MSC_VER_VC120
47	# pragma warning(disable:4748)
48	# endif
49	#endif
50
51	enum
52	{
53	MODIFYVM_NAME = 1000,
54	MODIFYVM_GROUPS,
55	MODIFYVM_DESCRIPTION,
56	MODIFYVM_OSTYPE,
57	MODIFYVM_ICONFILE,
58	MODIFYVM_MEMORY,
59	MODIFYVM_PAGEFUSION,
60	MODIFYVM_VRAM,
61	MODIFYVM_FIRMWARE,
62	MODIFYVM_ACPI,
63	MODIFYVM_IOAPIC,
64	MODIFYVM_PAE,
65	MODIFYVM_LONGMODE,
66	MODIFYVM_CPUID_PORTABILITY,
67	MODIFYVM_TFRESET,
68	MODIFYVM_APIC,
69	MODIFYVM_X2APIC,
70	MODIFYVM_PARAVIRTPROVIDER,
71	MODIFYVM_PARAVIRTDEBUG,
72	MODIFYVM_HWVIRTEX,
73	MODIFYVM_NESTEDPAGING,
74	MODIFYVM_LARGEPAGES,
75	MODIFYVM_VTXVPID,
76	MODIFYVM_VTXUX,
77	MODIFYVM_CPUS,
78	MODIFYVM_CPUHOTPLUG,
79	MODIFYVM_CPU_PROFILE,
80	MODIFYVM_PLUGCPU,
81	MODIFYVM_UNPLUGCPU,
82	MODIFYVM_SETCPUID,
83	MODIFYVM_SETCPUID_OLD,
84	MODIFYVM_DELCPUID,
85	MODIFYVM_DELCPUID_OLD,
86	MODIFYVM_DELALLCPUID,
87	MODIFYVM_GRAPHICSCONTROLLER,
88	MODIFYVM_MONITORCOUNT,
89	MODIFYVM_ACCELERATE3D,
90	#ifdef VBOX_WITH_VIDEOHWACCEL
91	MODIFYVM_ACCELERATE2DVIDEO,
92	#endif
93	MODIFYVM_BIOSLOGOFADEIN,
94	MODIFYVM_BIOSLOGOFADEOUT,
95	MODIFYVM_BIOSLOGODISPLAYTIME,
96	MODIFYVM_BIOSLOGOIMAGEPATH,
97	MODIFYVM_BIOSBOOTMENU,
98	MODIFYVM_BIOSAPIC,
99	MODIFYVM_BIOSSYSTEMTIMEOFFSET,
100	MODIFYVM_BIOSPXEDEBUG,
101	MODIFYVM_BOOT,
102	MODIFYVM_HDA, // deprecated
103	MODIFYVM_HDB, // deprecated
104	MODIFYVM_HDD, // deprecated
105	MODIFYVM_IDECONTROLLER, // deprecated
106	MODIFYVM_SATAPORTCOUNT, // deprecated
107	MODIFYVM_SATAPORT, // deprecated
108	MODIFYVM_SATA, // deprecated
109	MODIFYVM_SCSIPORT, // deprecated
110	MODIFYVM_SCSITYPE, // deprecated
111	MODIFYVM_SCSI, // deprecated
112	MODIFYVM_DVDPASSTHROUGH, // deprecated
113	MODIFYVM_DVD, // deprecated
114	MODIFYVM_FLOPPY, // deprecated
115	MODIFYVM_NICTRACEFILE,
116	MODIFYVM_NICTRACE,
117	MODIFYVM_NICPROPERTY,
118	MODIFYVM_NICTYPE,
119	MODIFYVM_NICSPEED,
120	MODIFYVM_NICBOOTPRIO,
121	MODIFYVM_NICPROMISC,
122	MODIFYVM_NICBWGROUP,
123	MODIFYVM_NIC,
124	MODIFYVM_CABLECONNECTED,
125	MODIFYVM_BRIDGEADAPTER,
126	MODIFYVM_HOSTONLYADAPTER,
127	MODIFYVM_INTNET,
128	MODIFYVM_GENERICDRV,
129	MODIFYVM_NATNETWORKNAME,
130	MODIFYVM_NATNET,
131	MODIFYVM_NATBINDIP,
132	MODIFYVM_NATSETTINGS,
133	MODIFYVM_NATPF,
134	MODIFYVM_NATALIASMODE,
135	MODIFYVM_NATTFTPPREFIX,
136	MODIFYVM_NATTFTPFILE,
137	MODIFYVM_NATTFTPSERVER,
138	MODIFYVM_NATDNSPASSDOMAIN,
139	MODIFYVM_NATDNSPROXY,
140	MODIFYVM_NATDNSHOSTRESOLVER,
141	MODIFYVM_MACADDRESS,
142	MODIFYVM_HIDPTR,
143	MODIFYVM_HIDKBD,
144	MODIFYVM_UARTMODE,
145	MODIFYVM_UART,
146	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
147	MODIFYVM_LPTMODE,
148	MODIFYVM_LPT,
149	#endif
150	MODIFYVM_GUESTMEMORYBALLOON,
151	MODIFYVM_AUDIOCONTROLLER,
152	MODIFYVM_AUDIOCODEC,
153	MODIFYVM_AUDIO,
154	MODIFYVM_AUDIOIN,
155	MODIFYVM_AUDIOOUT,
156	MODIFYVM_CLIPBOARD,
157	MODIFYVM_DRAGANDDROP,
158	MODIFYVM_VRDPPORT, /* VRDE: deprecated */
159	MODIFYVM_VRDPADDRESS, /* VRDE: deprecated */
160	MODIFYVM_VRDPAUTHTYPE, /* VRDE: deprecated */
161	MODIFYVM_VRDPMULTICON, /* VRDE: deprecated */
162	MODIFYVM_VRDPREUSECON, /* VRDE: deprecated */
163	MODIFYVM_VRDPVIDEOCHANNEL, /* VRDE: deprecated */
164	MODIFYVM_VRDPVIDEOCHANNELQUALITY, /* VRDE: deprecated */
165	MODIFYVM_VRDP, /* VRDE: deprecated */
166	MODIFYVM_VRDEPROPERTY,
167	MODIFYVM_VRDEPORT,
168	MODIFYVM_VRDEADDRESS,
169	MODIFYVM_VRDEAUTHTYPE,
170	MODIFYVM_VRDEAUTHLIBRARY,
171	MODIFYVM_VRDEMULTICON,
172	MODIFYVM_VRDEREUSECON,
173	MODIFYVM_VRDEVIDEOCHANNEL,
174	MODIFYVM_VRDEVIDEOCHANNELQUALITY,
175	MODIFYVM_VRDE_EXTPACK,
176	MODIFYVM_VRDE,
177	MODIFYVM_RTCUSEUTC,
178	MODIFYVM_USBRENAME,
179	MODIFYVM_USBXHCI,
180	MODIFYVM_USBEHCI,
181	MODIFYVM_USBOHCI,
182	MODIFYVM_SNAPSHOTFOLDER,
183	MODIFYVM_TELEPORTER_ENABLED,
184	MODIFYVM_TELEPORTER_PORT,
185	MODIFYVM_TELEPORTER_ADDRESS,
186	MODIFYVM_TELEPORTER_PASSWORD,
187	MODIFYVM_TELEPORTER_PASSWORD_FILE,
188	MODIFYVM_TRACING_ENABLED,
189	MODIFYVM_TRACING_CONFIG,
190	MODIFYVM_TRACING_ALLOW_VM_ACCESS,
191	MODIFYVM_HARDWARE_UUID,
192	MODIFYVM_HPET,
193	MODIFYVM_IOCACHE,
194	MODIFYVM_IOCACHESIZE,
195	MODIFYVM_FAULT_TOLERANCE,
196	MODIFYVM_FAULT_TOLERANCE_ADDRESS,
197	MODIFYVM_FAULT_TOLERANCE_PORT,
198	MODIFYVM_FAULT_TOLERANCE_PASSWORD,
199	MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL,
200	MODIFYVM_CPU_EXECTUION_CAP,
201	MODIFYVM_AUTOSTART_ENABLED,
202	MODIFYVM_AUTOSTART_DELAY,
203	MODIFYVM_AUTOSTOP_TYPE,
204	#ifdef VBOX_WITH_PCI_PASSTHROUGH
205	MODIFYVM_ATTACH_PCI,
206	MODIFYVM_DETACH_PCI,
207	#endif
208	#ifdef VBOX_WITH_USB_CARDREADER
209	MODIFYVM_USBCARDREADER,
210	#endif
211	#ifdef VBOX_WITH_VIDEOREC
212	MODIFYVM_VIDEOCAP,
213	MODIFYVM_VIDEOCAP_SCREENS,
214	MODIFYVM_VIDEOCAP_FILENAME,
215	MODIFYVM_VIDEOCAP_WIDTH,
216	MODIFYVM_VIDEOCAP_HEIGHT,
217	MODIFYVM_VIDEOCAP_RES,
218	MODIFYVM_VIDEOCAP_RATE,
219	MODIFYVM_VIDEOCAP_FPS,
220	MODIFYVM_VIDEOCAP_MAXTIME,
221	MODIFYVM_VIDEOCAP_MAXSIZE,
222	MODIFYVM_VIDEOCAP_OPTIONS,
223	#endif
224	MODIFYVM_CHIPSET,
225	MODIFYVM_DEFAULTFRONTEND
226	};
227
228	static const RTGETOPTDEF g_aModifyVMOptions[] =
229	{
230	/** @todo Convert to dash separated names like --triple-fault-reset! Please
231	* do that for all new options as we don't need more character soups
232	* around VirtualBox - typedefs more than covers that demand! */
233	{ "--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING },
234	{ "--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING },
235	{ "--description", MODIFYVM_DESCRIPTION, RTGETOPT_REQ_STRING },
236	{ "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING },
237	{ "--iconfile", MODIFYVM_ICONFILE, RTGETOPT_REQ_STRING },
238	{ "--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32 },
239	{ "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF },
240	{ "--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32 },
241	{ "--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING },
242	{ "--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF },
243	{ "--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF },
244	{ "--pae", MODIFYVM_PAE, RTGETOPT_REQ_BOOL_ONOFF },
245	{ "--longmode", MODIFYVM_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF },
246	{ "--cpuid-portability-level", MODIFYVM_CPUID_PORTABILITY, RTGETOPT_REQ_UINT32 },
247	{ "--triplefaultreset", MODIFYVM_TFRESET, RTGETOPT_REQ_BOOL_ONOFF },
248	{ "--apic", MODIFYVM_APIC, RTGETOPT_REQ_BOOL_ONOFF },
249	{ "--x2apic", MODIFYVM_X2APIC, RTGETOPT_REQ_BOOL_ONOFF },
250	{ "--paravirtprovider", MODIFYVM_PARAVIRTPROVIDER, RTGETOPT_REQ_STRING },
251	{ "--paravirtdebug", MODIFYVM_PARAVIRTDEBUG, RTGETOPT_REQ_STRING },
252	{ "--hwvirtex", MODIFYVM_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF },
253	{ "--nestedpaging", MODIFYVM_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF },
254	{ "--largepages", MODIFYVM_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF },
255	{ "--vtxvpid", MODIFYVM_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF },
256	{ "--vtxux", MODIFYVM_VTXUX, RTGETOPT_REQ_BOOL_ONOFF },
257	{ "--cpuid-set", MODIFYVM_SETCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR \| RTGETOPT_FLAG_HEX },
258	{ "--cpuid-remove", MODIFYVM_DELCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR \| RTGETOPT_FLAG_HEX },
259	{ "--cpuidset", MODIFYVM_SETCPUID_OLD, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX },
260	{ "--cpuidremove", MODIFYVM_DELCPUID_OLD, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX },
261	{ "--cpuidremoveall", MODIFYVM_DELALLCPUID, RTGETOPT_REQ_NOTHING},
262	{ "--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32 },
263	{ "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF },
264	{ "--cpu-profile", MODIFYVM_CPU_PROFILE, RTGETOPT_REQ_STRING },
265	{ "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32 },
266	{ "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32 },
267	{ "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32 },
268	{ "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF },
269	{ "--graphicscontroller", MODIFYVM_GRAPHICSCONTROLLER, RTGETOPT_REQ_STRING },
270	{ "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32 },
271	{ "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF },
272	#ifdef VBOX_WITH_VIDEOHWACCEL
273	{ "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF },
274	#endif
275	{ "--bioslogofadein", MODIFYVM_BIOSLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF },
276	{ "--bioslogofadeout", MODIFYVM_BIOSLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF },
277	{ "--bioslogodisplaytime", MODIFYVM_BIOSLOGODISPLAYTIME, RTGETOPT_REQ_UINT32 },
278	{ "--bioslogoimagepath", MODIFYVM_BIOSLOGOIMAGEPATH, RTGETOPT_REQ_STRING },
279	{ "--biosbootmenu", MODIFYVM_BIOSBOOTMENU, RTGETOPT_REQ_STRING },
280	{ "--biossystemtimeoffset", MODIFYVM_BIOSSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64 },
281	{ "--biosapic", MODIFYVM_BIOSAPIC, RTGETOPT_REQ_STRING },
282	{ "--biospxedebug", MODIFYVM_BIOSPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF },
283	{ "--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
284	{ "--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING },
285	{ "--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING },
286	{ "--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING },
287	{ "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING },
288	{ "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32 },
289	{ "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
290	{ "--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING },
291	{ "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
292	{ "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING },
293	{ "--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING },
294	{ "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING },
295	{ "--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING },
296	{ "--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING },
297	{ "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
298	{ "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
299	{ "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
300	{ "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
301	{ "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_INDEX },
302	{ "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_INDEX },
303	{ "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
304	{ "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
305	{ "--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
306	{ "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
307	{ "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
308	{ "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
309	{ "--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
310	{ "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
311	{ "--nat-network", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
312	{ "--natnetwork", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
313	{ "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
314	{ "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
315	{ "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
316	{ "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
317	{ "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
318	{ "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
319	{ "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
320	{ "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
321	{ "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
322	{ "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
323	{ "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF \| RTGETOPT_FLAG_INDEX },
324	{ "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
325	{ "--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING },
326	{ "--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING },
327	{ "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
328	{ "--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
329	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
330	{ "--lptmode", MODIFYVM_LPTMODE, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
331	{ "--lpt", MODIFYVM_LPT, RTGETOPT_REQ_STRING \| RTGETOPT_FLAG_INDEX },
332	#endif
333	{ "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32 },
334	{ "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING },
335	{ "--audiocodec", MODIFYVM_AUDIOCODEC, RTGETOPT_REQ_STRING },
336	{ "--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING },
337	{ "--audioin", MODIFYVM_AUDIOIN, RTGETOPT_REQ_BOOL_ONOFF },
338	{ "--audioout", MODIFYVM_AUDIOOUT, RTGETOPT_REQ_BOOL_ONOFF },
339	{ "--clipboard", MODIFYVM_CLIPBOARD, RTGETOPT_REQ_STRING },
340	{ "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING },
341	{ "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING }, /* deprecated */
342	{ "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING }, /* deprecated */
343	{ "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING }, /* deprecated */
344	{ "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
345	{ "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
346	{ "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
347	{ "--vrdpvideochannelquality", MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING }, /* deprecated */
348	{ "--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
349	{ "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING },
350	{ "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING },
351	{ "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING },
352	{ "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING },
353	{ "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING },
354	{ "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF },
355	{ "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF },
356	{ "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF },
357	{ "--vrdevideochannelquality", MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING },
358	{ "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING },
359	{ "--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF },
360	{ "--usbrename", MODIFYVM_USBRENAME, RTGETOPT_REQ_STRING },
361	{ "--usbxhci", MODIFYVM_USBXHCI, RTGETOPT_REQ_BOOL_ONOFF },
362	{ "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF },
363	{ "--usbohci", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF },
364	{ "--usb", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
365	{ "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING },
366	{ "--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
367	{ "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
368	{ "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32 },
369	{ "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING },
370	{ "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING },
371	{ "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING },
372	{ "--tracing-enabled", MODIFYVM_TRACING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
373	{ "--tracing-config", MODIFYVM_TRACING_CONFIG, RTGETOPT_REQ_STRING },
374	{ "--tracing-allow-vm-access", MODIFYVM_TRACING_ALLOW_VM_ACCESS, RTGETOPT_REQ_BOOL_ONOFF },
375	{ "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING },
376	{ "--hpet", MODIFYVM_HPET, RTGETOPT_REQ_BOOL_ONOFF },
377	{ "--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF },
378	{ "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32 },
379	{ "--faulttolerance", MODIFYVM_FAULT_TOLERANCE, RTGETOPT_REQ_STRING },
380	{ "--faulttoleranceaddress", MODIFYVM_FAULT_TOLERANCE_ADDRESS, RTGETOPT_REQ_STRING },
381	{ "--faulttoleranceport", MODIFYVM_FAULT_TOLERANCE_PORT, RTGETOPT_REQ_UINT32 },
382	{ "--faulttolerancepassword", MODIFYVM_FAULT_TOLERANCE_PASSWORD, RTGETOPT_REQ_STRING },
383	{ "--faulttolerancesyncinterval", MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL, RTGETOPT_REQ_UINT32 },
384	{ "--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING },
385	#ifdef VBOX_WITH_VIDEOREC
386	{ "--videocap", MODIFYVM_VIDEOCAP, RTGETOPT_REQ_BOOL_ONOFF },
387	{ "--vcpenabled", MODIFYVM_VIDEOCAP, RTGETOPT_REQ_BOOL_ONOFF }, /* deprecated */
388	{ "--videocapscreens", MODIFYVM_VIDEOCAP_SCREENS, RTGETOPT_REQ_STRING },
389	{ "--vcpscreens", MODIFYVM_VIDEOCAP_SCREENS, RTGETOPT_REQ_STRING }, /* deprecated */
390	{ "--videocapfile", MODIFYVM_VIDEOCAP_FILENAME, RTGETOPT_REQ_STRING },
391	{ "--vcpfile", MODIFYVM_VIDEOCAP_FILENAME, RTGETOPT_REQ_STRING }, /* deprecated */
392	{ "--videocapres", MODIFYVM_VIDEOCAP_RES, RTGETOPT_REQ_STRING },
393	{ "--vcpwidth", MODIFYVM_VIDEOCAP_WIDTH, RTGETOPT_REQ_UINT32 }, /* deprecated */
394	{ "--vcpheight", MODIFYVM_VIDEOCAP_HEIGHT, RTGETOPT_REQ_UINT32 }, /* deprecated */
395	{ "--videocaprate", MODIFYVM_VIDEOCAP_RATE, RTGETOPT_REQ_UINT32 },
396	{ "--vcprate", MODIFYVM_VIDEOCAP_RATE, RTGETOPT_REQ_UINT32 }, /* deprecated */
397	{ "--videocapfps", MODIFYVM_VIDEOCAP_FPS, RTGETOPT_REQ_UINT32 },
398	{ "--vcpfps", MODIFYVM_VIDEOCAP_FPS, RTGETOPT_REQ_UINT32 }, /* deprecated */
399	{ "--videocapmaxtime", MODIFYVM_VIDEOCAP_MAXTIME, RTGETOPT_REQ_INT32 },
400	{ "--vcpmaxtime", MODIFYVM_VIDEOCAP_MAXTIME, RTGETOPT_REQ_INT32 }, /* deprecated */
401	{ "--videocapmaxsize", MODIFYVM_VIDEOCAP_MAXSIZE, RTGETOPT_REQ_INT32 },
402	{ "--vcpmaxsize", MODIFYVM_VIDEOCAP_MAXSIZE, RTGETOPT_REQ_INT32 }, /* deprecated */
403	{ "--videocapopts", MODIFYVM_VIDEOCAP_OPTIONS, RTGETOPT_REQ_STRING },
404	{ "--vcpoptions", MODIFYVM_VIDEOCAP_OPTIONS, RTGETOPT_REQ_STRING }, /* deprecated */
405	#endif
406	{ "--autostart-enabled", MODIFYVM_AUTOSTART_ENABLED, RTGETOPT_REQ_BOOL_ONOFF },
407	{ "--autostart-delay", MODIFYVM_AUTOSTART_DELAY, RTGETOPT_REQ_UINT32 },
408	{ "--autostop-type", MODIFYVM_AUTOSTOP_TYPE, RTGETOPT_REQ_STRING },
409	#ifdef VBOX_WITH_PCI_PASSTHROUGH
410	{ "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING },
411	{ "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING },
412	#endif
413	#ifdef VBOX_WITH_USB_CARDREADER
414	{ "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF },
415	#endif
416	{ "--defaultfrontend", MODIFYVM_DEFAULTFRONTEND, RTGETOPT_REQ_STRING },
417	};
418
419	static void vrdeWarningDeprecatedOption(const char *pszOption)
420	{
421	RTStrmPrintf(g_pStdErr, "Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n", pszOption, pszOption);
422	}
423
424	/** Parse PCI address in format 01:02.03 and convert it to the numeric representation. */
425	static int32_t parsePci(const char* szPciAddr)
426	{
427	char* pszNext = (char*)szPciAddr;
428	int rc;
429	uint8_t aVals[3] = {0, 0, 0};
430
431	rc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
432	if (RT_FAILURE(rc) \|\| pszNext == NULL \|\| *pszNext != ':')
433	return -1;
434
435	rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
436	if (RT_FAILURE(rc) \|\| pszNext == NULL \|\| *pszNext != '.')
437	return -1;
438
439	rc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
440	if (RT_FAILURE(rc) \|\| pszNext == NULL)
441	return -1;
442
443	return (aVals[0] << 8) \| (aVals[1] << 3) \| (aVals[2] << 0);
444	}
445
446	void parseGroups(const char pcszGroups, com::SafeArray<BSTR> pGroups)
447	{
448	while (pcszGroups)
449	{
450	char *pComma = RTStrStr(pcszGroups, ",");
451	if (pComma)
452	{
453	Bstr(pcszGroups, pComma - pcszGroups).detachTo(pGroups->appendedRaw());
454	pcszGroups = pComma + 1;
455	}
456	else
457	{
458	Bstr(pcszGroups).detachTo(pGroups->appendedRaw());
459	pcszGroups = NULL;
460	}
461	}
462	}
463
464	#ifdef VBOX_WITH_VIDEOREC
465	static int parseScreens(const char pcszScreens, com::SafeArray<BOOL> pScreens)
466	{
467	while (pcszScreens && *pcszScreens)
468	{
469	char *pszNext;
470	uint32_t iScreen;
471	int rc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
472	if (RT_FAILURE(rc))
473	return 1;
474	if (iScreen >= pScreens->size())
475	return 1;
476	if (pszNext && *pszNext)
477	{
478	pszNext = RTStrStripL(pszNext);
479	if (*pszNext != ',')
480	return 1;
481	pszNext++;
482	}
483	(*pScreens)[iScreen] = true;
484	pcszScreens = pszNext;
485	}
486	return 0;
487	}
488	#endif
489
490	static int parseNum(uint32_t uIndex, unsigned cMaxIndex, const char *pszName)
491	{
492	if ( uIndex >= 1
493	&& uIndex <= cMaxIndex)
494	return uIndex;
495	errorArgument("Invalid %s number %u", pszName, uIndex);
496	return 0;
497	}
498
499	RTEXITCODE handleModifyVM(HandlerArg *a)
500	{
501	int c;
502	HRESULT rc;
503	Bstr name;
504
505	/* VM ID + at least one parameter. Parameter arguments are checked
506	* individually. */
507	if (a->argc < 2)
508	return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
509
510	/* try to find the given sessionMachine */
511	ComPtr<IMachine> machine;
512	CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
513	machine.asOutParam()), RTEXITCODE_FAILURE);
514
515
516	/* Get the number of network adapters */
517	ULONG NetworkAdapterCount = getMaxNics(a->virtualBox, machine);
518
519	/* open a session for the VM */
520	CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
521
522	/* get the mutable session sessionMachine */
523	ComPtr<IMachine> sessionMachine;
524	CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
525
526	ComPtr<IBIOSSettings> biosSettings;
527	sessionMachine->COMGETTER(BIOSSettings)(biosSettings.asOutParam());
528
529	RTGETOPTSTATE GetOptState;
530	RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
531	RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
532
533	RTGETOPTUNION ValueUnion;
534	while ( SUCCEEDED (rc)
535	&& (c = RTGetOpt(&GetOptState, &ValueUnion)))
536	{
537	switch (c)
538	{
539	case MODIFYVM_NAME:
540	{
541	CHECK_ERROR(sessionMachine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
542	break;
543	}
544	case MODIFYVM_GROUPS:
545	{
546	com::SafeArray<BSTR> groups;
547	parseGroups(ValueUnion.psz, &groups);
548	CHECK_ERROR(sessionMachine, COMSETTER(Groups)(ComSafeArrayAsInParam(groups)));
549	break;
550	}
551	case MODIFYVM_DESCRIPTION:
552	{
553	CHECK_ERROR(sessionMachine, COMSETTER(Description)(Bstr(ValueUnion.psz).raw()));
554	break;
555	}
556	case MODIFYVM_OSTYPE:
557	{
558	ComPtr<IGuestOSType> guestOSType;
559	CHECK_ERROR(a->virtualBox, GetGuestOSType(Bstr(ValueUnion.psz).raw(),
560	guestOSType.asOutParam()));
561	if (SUCCEEDED(rc) && guestOSType)
562	{
563	CHECK_ERROR(sessionMachine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
564	}
565	else
566	{
567	errorArgument("Invalid guest OS type '%s'", ValueUnion.psz);
568	rc = E_FAIL;
569	}
570	break;
571	}
572
573	case MODIFYVM_ICONFILE:
574	{
575	RTFILE iconFile;
576	int vrc = RTFileOpen(&iconFile, ValueUnion.psz, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_WRITE);
577	if (RT_FAILURE(vrc))
578	{
579	RTMsgError("Cannot open file \"%s\": %Rrc", ValueUnion.psz, vrc);
580	rc = E_FAIL;
581	break;
582	}
583	uint64_t cbSize;
584	vrc = RTFileGetSize(iconFile, &cbSize);
585	if (RT_FAILURE(vrc))
586	{
587	RTMsgError("Cannot get size of file \"%s\": %Rrc", ValueUnion.psz, vrc);
588	rc = E_FAIL;
589	break;
590	}
591	if (cbSize > _256K)
592	{
593	RTMsgError("File \"%s\" is bigger than 256KByte", ValueUnion.psz);
594	rc = E_FAIL;
595	break;
596	}
597	SafeArray<BYTE> icon((size_t)cbSize);
598	rc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
599	if (RT_FAILURE(vrc))
600	{
601	RTMsgError("Cannot read contents of file \"%s\": %Rrc", ValueUnion.psz, vrc);
602	rc = E_FAIL;
603	break;
604	}
605	RTFileClose(iconFile);
606	CHECK_ERROR(sessionMachine, COMSETTER(Icon)(ComSafeArrayAsInParam(icon)));
607	break;
608	}
609
610	case MODIFYVM_MEMORY:
611	{
612	CHECK_ERROR(sessionMachine, COMSETTER(MemorySize)(ValueUnion.u32));
613	break;
614	}
615
616	case MODIFYVM_PAGEFUSION:
617	{
618	CHECK_ERROR(sessionMachine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
619	break;
620	}
621
622	case MODIFYVM_VRAM:
623	{
624	CHECK_ERROR(sessionMachine, COMSETTER(VRAMSize)(ValueUnion.u32));
625	break;
626	}
627
628	case MODIFYVM_FIRMWARE:
629	{
630	if (!RTStrICmp(ValueUnion.psz, "efi"))
631	{
632	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI));
633	}
634	else if (!RTStrICmp(ValueUnion.psz, "efi32"))
635	{
636	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI32));
637	}
638	else if (!RTStrICmp(ValueUnion.psz, "efi64"))
639	{
640	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFI64));
641	}
642	else if (!RTStrICmp(ValueUnion.psz, "efidual"))
643	{
644	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
645	}
646	else if (!RTStrICmp(ValueUnion.psz, "bios"))
647	{
648	CHECK_ERROR(sessionMachine, COMSETTER(FirmwareType)(FirmwareType_BIOS));
649	}
650	else
651	{
652	errorArgument("Invalid --firmware argument '%s'", ValueUnion.psz);
653	rc = E_FAIL;
654	}
655	break;
656	}
657
658	case MODIFYVM_ACPI:
659	{
660	CHECK_ERROR(biosSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
661	break;
662	}
663
664	case MODIFYVM_IOAPIC:
665	{
666	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
667	break;
668	}
669
670	case MODIFYVM_PAE:
671	{
672	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_PAE, ValueUnion.f));
673	break;
674	}
675
676	case MODIFYVM_LONGMODE:
677	{
678	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_LongMode, ValueUnion.f));
679	break;
680	}
681
682	case MODIFYVM_CPUID_PORTABILITY:
683	{
684	CHECK_ERROR(sessionMachine, COMSETTER(CPUIDPortabilityLevel)(ValueUnion.u32));
685	break;
686	}
687
688	case MODIFYVM_TFRESET:
689	{
690	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_TripleFaultReset, ValueUnion.f));
691	break;
692	}
693
694	case MODIFYVM_APIC:
695	{
696	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_APIC, ValueUnion.f));
697	break;
698	}
699
700	case MODIFYVM_X2APIC:
701	{
702	CHECK_ERROR(sessionMachine, SetCPUProperty(CPUPropertyType_X2APIC, ValueUnion.f));
703	break;
704	}
705
706	case MODIFYVM_PARAVIRTPROVIDER:
707	{
708	if ( !RTStrICmp(ValueUnion.psz, "none")
709	\|\| !RTStrICmp(ValueUnion.psz, "disabled"))
710	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_None));
711	else if (!RTStrICmp(ValueUnion.psz, "default"))
712	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Default));
713	else if (!RTStrICmp(ValueUnion.psz, "legacy"))
714	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Legacy));
715	else if (!RTStrICmp(ValueUnion.psz, "minimal"))
716	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Minimal));
717	else if (!RTStrICmp(ValueUnion.psz, "hyperv"))
718	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_HyperV));
719	else if (!RTStrICmp(ValueUnion.psz, "kvm"))
720	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_KVM));
721	else
722	{
723	errorArgument("Invalid --paravirtprovider argument '%s'", ValueUnion.psz);
724	rc = E_FAIL;
725	}
726	break;
727	}
728
729	case MODIFYVM_PARAVIRTDEBUG:
730	{
731	CHECK_ERROR(sessionMachine, COMSETTER(ParavirtDebug)(Bstr(ValueUnion.psz).raw()));
732	break;
733	}
734
735	case MODIFYVM_HWVIRTEX:
736	{
737	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, ValueUnion.f));
738	break;
739	}
740
741	case MODIFYVM_SETCPUID:
742	case MODIFYVM_SETCPUID_OLD:
743	{
744	uint32_t const idx = c == MODIFYVM_SETCPUID ? ValueUnion.PairU32.uFirst : ValueUnion.u32;
745	uint32_t const idxSub = c == MODIFYVM_SETCPUID ? ValueUnion.PairU32.uSecond : UINT32_MAX;
746	uint32_t aValue[4];
747	for (unsigned i = 0; i < 4; i++)
748	{
749	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32 \| RTGETOPT_FLAG_HEX);
750	if (RT_FAILURE(vrc))
751	return errorSyntax(USAGE_MODIFYVM, "Missing or Invalid argument to '%s'", GetOptState.pDef->pszLong);
752	aValue[i] = ValueUnion.u32;
753	}
754	CHECK_ERROR(sessionMachine, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3]));
755	break;
756	}
757
758	case MODIFYVM_DELCPUID:
759	CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.PairU32.uFirst, ValueUnion.PairU32.uSecond));
760	break;
761
762	case MODIFYVM_DELCPUID_OLD:
763	CHECK_ERROR(sessionMachine, RemoveCPUIDLeaf(ValueUnion.u32, UINT32_MAX));
764	break;
765
766	case MODIFYVM_DELALLCPUID:
767	{
768	CHECK_ERROR(sessionMachine, RemoveAllCPUIDLeaves());
769	break;
770	}
771
772	case MODIFYVM_NESTEDPAGING:
773	{
774	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, ValueUnion.f));
775	break;
776	}
777
778	case MODIFYVM_LARGEPAGES:
779	{
780	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, ValueUnion.f));
781	break;
782	}
783
784	case MODIFYVM_VTXVPID:
785	{
786	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_VPID, ValueUnion.f));
787	break;
788	}
789
790	case MODIFYVM_VTXUX:
791	{
792	CHECK_ERROR(sessionMachine, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, ValueUnion.f));
793	break;
794	}
795
796	case MODIFYVM_CPUS:
797	{
798	CHECK_ERROR(sessionMachine, COMSETTER(CPUCount)(ValueUnion.u32));
799	break;
800	}
801
802	case MODIFYVM_RTCUSEUTC:
803	{
804	CHECK_ERROR(sessionMachine, COMSETTER(RTCUseUTC)(ValueUnion.f));
805	break;
806	}
807
808	case MODIFYVM_CPUHOTPLUG:
809	{
810	CHECK_ERROR(sessionMachine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
811	break;
812	}
813
814	case MODIFYVM_CPU_PROFILE:
815	{
816	CHECK_ERROR(sessionMachine, COMSETTER(CPUProfile)(Bstr(ValueUnion.psz).raw()));
817	break;
818	}
819
820	case MODIFYVM_PLUGCPU:
821	{
822	CHECK_ERROR(sessionMachine, HotPlugCPU(ValueUnion.u32));
823	break;
824	}
825
826	case MODIFYVM_UNPLUGCPU:
827	{
828	CHECK_ERROR(sessionMachine, HotUnplugCPU(ValueUnion.u32));
829	break;
830	}
831
832	case MODIFYVM_CPU_EXECTUION_CAP:
833	{
834	CHECK_ERROR(sessionMachine, COMSETTER(CPUExecutionCap)(ValueUnion.u32));
835	break;
836	}
837
838	case MODIFYVM_GRAPHICSCONTROLLER:
839	{
840	if ( !RTStrICmp(ValueUnion.psz, "none")
841	\|\| !RTStrICmp(ValueUnion.psz, "disabled"))
842	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_Null));
843	else if ( !RTStrICmp(ValueUnion.psz, "vboxvga")
844	\|\| !RTStrICmp(ValueUnion.psz, "vbox")
845	\|\| !RTStrICmp(ValueUnion.psz, "vga")
846	\|\| !RTStrICmp(ValueUnion.psz, "vesa"))
847	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxVGA));
848	#ifdef VBOX_WITH_VMSVGA
849	else if ( !RTStrICmp(ValueUnion.psz, "vmsvga")
850	\|\| !RTStrICmp(ValueUnion.psz, "vmware"))
851	CHECK_ERROR(sessionMachine, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VMSVGA));
852	#endif
853	else
854	{
855	errorArgument("Invalid --graphicscontroller argument '%s'", ValueUnion.psz);
856	rc = E_FAIL;
857	}
858	break;
859	}
860
861	case MODIFYVM_MONITORCOUNT:
862	{
863	CHECK_ERROR(sessionMachine, COMSETTER(MonitorCount)(ValueUnion.u32));
864	break;
865	}
866
867	case MODIFYVM_ACCELERATE3D:
868	{
869	CHECK_ERROR(sessionMachine, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
870	break;
871	}
872
873	#ifdef VBOX_WITH_VIDEOHWACCEL
874	case MODIFYVM_ACCELERATE2DVIDEO:
875	{
876	CHECK_ERROR(sessionMachine, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
877	break;
878	}
879	#endif
880
881	case MODIFYVM_BIOSLOGOFADEIN:
882	{
883	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
884	break;
885	}
886
887	case MODIFYVM_BIOSLOGOFADEOUT:
888	{
889	CHECK_ERROR(biosSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
890	break;
891	}
892
893	case MODIFYVM_BIOSLOGODISPLAYTIME:
894	{
895	CHECK_ERROR(biosSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
896	break;
897	}
898
899	case MODIFYVM_BIOSLOGOIMAGEPATH:
900	{
901	CHECK_ERROR(biosSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
902	break;
903	}
904
905	case MODIFYVM_BIOSBOOTMENU:
906	{
907	if (!RTStrICmp(ValueUnion.psz, "disabled"))
908	{
909	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_Disabled));
910	}
911	else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
912	{
913	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MenuOnly));
914	}
915	else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
916	{
917	CHECK_ERROR(biosSettings, COMSETTER(BootMenuMode)(BIOSBootMenuMode_MessageAndMenu));
918	}
919	else
920	{
921	errorArgument("Invalid --biosbootmenu argument '%s'", ValueUnion.psz);
922	rc = E_FAIL;
923	}
924	break;
925	}
926
927	case MODIFYVM_BIOSAPIC:
928	{
929	if (!RTStrICmp(ValueUnion.psz, "disabled"))
930	{
931	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_Disabled));
932	}
933	else if ( !RTStrICmp(ValueUnion.psz, "apic")
934	\|\| !RTStrICmp(ValueUnion.psz, "lapic")
935	\|\| !RTStrICmp(ValueUnion.psz, "xapic"))
936	{
937	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_APIC));
938	}
939	else if (!RTStrICmp(ValueUnion.psz, "x2apic"))
940	{
941	CHECK_ERROR(biosSettings, COMSETTER(APICMode)(APICMode_X2APIC));
942	}
943	else
944	{
945	errorArgument("Invalid --biosapic argument '%s'", ValueUnion.psz);
946	rc = E_FAIL;
947	}
948	break;
949	}
950
951	case MODIFYVM_BIOSSYSTEMTIMEOFFSET:
952	{
953	CHECK_ERROR(biosSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
954	break;
955	}
956
957	case MODIFYVM_BIOSPXEDEBUG:
958	{
959	CHECK_ERROR(biosSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
960	break;
961	}
962
963	case MODIFYVM_BOOT:
964	{
965	if (!RTStrICmp(ValueUnion.psz, "none"))
966	{
967	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
968	}
969	else if (!RTStrICmp(ValueUnion.psz, "floppy"))
970	{
971	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
972	}
973	else if (!RTStrICmp(ValueUnion.psz, "dvd"))
974	{
975	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
976	}
977	else if (!RTStrICmp(ValueUnion.psz, "disk"))
978	{
979	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
980	}
981	else if (!RTStrICmp(ValueUnion.psz, "net"))
982	{
983	CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
984	}
985	else
986	return errorArgument("Invalid boot device '%s'", ValueUnion.psz);
987	break;
988	}
989
990	case MODIFYVM_HDA: // deprecated
991	case MODIFYVM_HDB: // deprecated
992	case MODIFYVM_HDD: // deprecated
993	case MODIFYVM_SATAPORT: // deprecated
994	{
995	uint32_t u1 = 0, u2 = 0;
996	Bstr bstrController = L"IDE Controller";
997
998	switch (c)
999	{
1000	case MODIFYVM_HDA: // deprecated
1001	u1 = 0;
1002	break;
1003
1004	case MODIFYVM_HDB: // deprecated
1005	u1 = 0;
1006	u2 = 1;
1007	break;
1008
1009	case MODIFYVM_HDD: // deprecated
1010	u1 = 1;
1011	u2 = 1;
1012	break;
1013
1014	case MODIFYVM_SATAPORT: // deprecated
1015	u1 = GetOptState.uIndex;
1016	bstrController = L"SATA";
1017	break;
1018	}
1019
1020	if (!RTStrICmp(ValueUnion.psz, "none"))
1021	{
1022	sessionMachine->DetachDevice(bstrController.raw(), u1, u2);
1023	}
1024	else
1025	{
1026	ComPtr<IMedium> hardDisk;
1027	rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1028	AccessMode_ReadWrite, hardDisk,
1029	false /* fForceNewUuidOnOpen */,
1030	false /* fSilent */);
1031	if (FAILED(rc))
1032	break;
1033	if (hardDisk)
1034	{
1035	CHECK_ERROR(sessionMachine, AttachDevice(bstrController.raw(),
1036	u1, u2,
1037	DeviceType_HardDisk,
1038	hardDisk));
1039	}
1040	else
1041	rc = E_FAIL;
1042	}
1043	break;
1044	}
1045
1046	case MODIFYVM_IDECONTROLLER: // deprecated
1047	{
1048	ComPtr<IStorageController> storageController;
1049	CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
1050	storageController.asOutParam()));
1051
1052	if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
1053	{
1054	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
1055	}
1056	else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
1057	{
1058	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
1059	}
1060	else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
1061	{
1062	CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
1063	}
1064	else
1065	{
1066	errorArgument("Invalid --idecontroller argument '%s'", ValueUnion.psz);
1067	rc = E_FAIL;
1068	}
1069	break;
1070	}
1071
1072	case MODIFYVM_SATAPORTCOUNT: // deprecated
1073	{
1074	ComPtr<IStorageController> SataCtl;
1075	CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("SATA").raw(),
1076	SataCtl.asOutParam()));
1077
1078	if (SUCCEEDED(rc) && ValueUnion.u32 > 0)
1079	CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
1080	break;
1081	}
1082
1083	case MODIFYVM_SATA: // deprecated
1084	{
1085	if (!RTStrICmp(ValueUnion.psz, "on") \|\| !RTStrICmp(ValueUnion.psz, "enable"))
1086	{
1087	ComPtr<IStorageController> ctl;
1088	CHECK_ERROR(sessionMachine, AddStorageController(Bstr("SATA").raw(),
1089	StorageBus_SATA,
1090	ctl.asOutParam()));
1091	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
1092	}
1093	else if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
1094	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw()));
1095	else
1096	return errorArgument("Invalid --usb argument '%s'", ValueUnion.psz);
1097	break;
1098	}
1099
1100	case MODIFYVM_SCSIPORT: // deprecated
1101	{
1102	if (!RTStrICmp(ValueUnion.psz, "none"))
1103	{
1104	rc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
1105	GetOptState.uIndex, 0);
1106	if (FAILED(rc))
1107	CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(),
1108	GetOptState.uIndex, 0));
1109	}
1110	else
1111	{
1112	ComPtr<IMedium> hardDisk;
1113	rc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1114	AccessMode_ReadWrite, hardDisk,
1115	false /* fForceNewUuidOnOpen */,
1116	false /* fSilent */);
1117	if (FAILED(rc))
1118	break;
1119	if (hardDisk)
1120	{
1121	rc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
1122	GetOptState.uIndex, 0,
1123	DeviceType_HardDisk,
1124	hardDisk);
1125	if (FAILED(rc))
1126	CHECK_ERROR(sessionMachine,
1127	AttachDevice(Bstr("BusLogic").raw(),
1128	GetOptState.uIndex, 0,
1129	DeviceType_HardDisk,
1130	hardDisk));
1131	}
1132	else
1133	rc = E_FAIL;
1134	}
1135	break;
1136	}
1137
1138	case MODIFYVM_SCSITYPE: // deprecated
1139	{
1140	ComPtr<IStorageController> ctl;
1141
1142	if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
1143	{
1144	rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1145	if (FAILED(rc))
1146	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1147
1148	CHECK_ERROR(sessionMachine,
1149	AddStorageController(Bstr("LsiLogic").raw(),
1150	StorageBus_SCSI,
1151	ctl.asOutParam()));
1152
1153	if (SUCCEEDED(rc))
1154	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1155	}
1156	else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
1157	{
1158	rc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
1159	if (FAILED(rc))
1160	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw()));
1161
1162	CHECK_ERROR(sessionMachine,
1163	AddStorageController(Bstr("BusLogic").raw(),
1164	StorageBus_SCSI,
1165	ctl.asOutParam()));
1166
1167	if (SUCCEEDED(rc))
1168	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1169	}
1170	else
1171	return errorArgument("Invalid --scsitype argument '%s'", ValueUnion.psz);
1172	break;
1173	}
1174
1175	case MODIFYVM_SCSI: // deprecated
1176	{
1177	if (!RTStrICmp(ValueUnion.psz, "on") \|\| !RTStrICmp(ValueUnion.psz, "enable"))
1178	{
1179	ComPtr<IStorageController> ctl;
1180
1181	CHECK_ERROR(sessionMachine, AddStorageController(Bstr("BusLogic").raw(),
1182	StorageBus_SCSI,
1183	ctl.asOutParam()));
1184	if (SUCCEEDED(rc))
1185	CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1186	}
1187	else if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
1188	{
1189	rc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1190	if (FAILED(rc))
1191	CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1192	}
1193	break;
1194	}
1195
1196	case MODIFYVM_DVDPASSTHROUGH: // deprecated
1197	{
1198	CHECK_ERROR(sessionMachine, PassthroughDevice(Bstr("IDE Controller").raw(),
1199	1, 0,
1200	!RTStrICmp(ValueUnion.psz, "on")));
1201	break;
1202	}
1203
1204	case MODIFYVM_DVD: // deprecated
1205	{
1206	ComPtr<IMedium> dvdMedium;
1207
1208	/* unmount? */
1209	if (!RTStrICmp(ValueUnion.psz, "none"))
1210	{
1211	/* nothing to do, NULL object will cause unmount */
1212	}
1213	/* host drive? */
1214	else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1215	{
1216	ComPtr<IHost> host;
1217	CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1218	rc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
1219	dvdMedium.asOutParam());
1220	if (!dvdMedium)
1221	{
1222	/* 2nd try: try with the real name, important on Linux+libhal */
1223	char szPathReal[RTPATH_MAX];
1224	if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
1225	{
1226	errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1227	rc = E_FAIL;
1228	break;
1229	}
1230	rc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
1231	dvdMedium.asOutParam());
1232	if (!dvdMedium)
1233	{
1234	errorArgument("Invalid host DVD drive name \"%s\"", ValueUnion.psz + 5);
1235	rc = E_FAIL;
1236	break;
1237	}
1238	}
1239	}
1240	else
1241	{
1242	rc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
1243	AccessMode_ReadOnly, dvdMedium,
1244	false /* fForceNewUuidOnOpen */,
1245	false /* fSilent */);
1246	if (FAILED(rc))
1247	break;
1248	if (!dvdMedium)
1249	{
1250	rc = E_FAIL;
1251	break;
1252	}
1253	}
1254
1255	CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller").raw(),
1256	1, 0,
1257	dvdMedium,
1258	FALSE /* aForce */));
1259	break;
1260	}
1261
1262	case MODIFYVM_FLOPPY: // deprecated
1263	{
1264	ComPtr<IMedium> floppyMedium;
1265	ComPtr<IMediumAttachment> floppyAttachment;
1266	sessionMachine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1267	0, 0, floppyAttachment.asOutParam());
1268
1269	/* disable? */
1270	if (!RTStrICmp(ValueUnion.psz, "disabled"))
1271	{
1272	/* disable the controller */
1273	if (floppyAttachment)
1274	CHECK_ERROR(sessionMachine, DetachDevice(Bstr("Floppy Controller").raw(),
1275	0, 0));
1276	}
1277	else
1278	{
1279	/* enable the controller */
1280	if (!floppyAttachment)
1281	CHECK_ERROR(sessionMachine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1282	0, 0,
1283	DeviceType_Floppy));
1284
1285	/* unmount? */
1286	if ( !RTStrICmp(ValueUnion.psz, "none")
1287	\|\| !RTStrICmp(ValueUnion.psz, "empty")) // deprecated
1288	{
1289	/* nothing to do, NULL object will cause unmount */
1290	}
1291	/* host drive? */
1292	else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1293	{
1294	ComPtr<IHost> host;
1295	CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1296	rc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1297	floppyMedium.asOutParam());
1298	if (!floppyMedium)
1299	{
1300	errorArgument("Invalid host floppy drive name \"%s\"", ValueUnion.psz + 5);
1301	rc = E_FAIL;
1302	break;
1303	}
1304	}
1305	else
1306	{
1307	rc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
1308	AccessMode_ReadWrite, floppyMedium,
1309	false /* fForceNewUuidOnOpen */,
1310	false /* fSilent */);
1311	if (FAILED(rc))
1312	break;
1313	if (!floppyMedium)
1314	{
1315	rc = E_FAIL;
1316	break;
1317	}
1318	}
1319	CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller").raw(),
1320	0, 0,
1321	floppyMedium,
1322	FALSE /* aForce */));
1323	}
1324	break;
1325	}
1326
1327	case MODIFYVM_NICTRACEFILE:
1328	{
1329
1330	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1331	break;
1332
1333	ComPtr<INetworkAdapter> nic;
1334	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1335	ASSERT(nic);
1336
1337	CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1338	break;
1339	}
1340
1341	case MODIFYVM_NICTRACE:
1342	{
1343	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1344	break;
1345
1346	ComPtr<INetworkAdapter> nic;
1347	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1348	ASSERT(nic);
1349
1350	CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1351	break;
1352	}
1353
1354	case MODIFYVM_NICPROPERTY:
1355	{
1356	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1357	break;
1358
1359	ComPtr<INetworkAdapter> nic;
1360	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1361	ASSERT(nic);
1362
1363	if (nic)
1364	{
1365	/* Parse 'name=value' */
1366	char *pszProperty = RTStrDup(ValueUnion.psz);
1367	if (pszProperty)
1368	{
1369	char *pDelimiter = strchr(pszProperty, '=');
1370	if (pDelimiter)
1371	{
1372	*pDelimiter = '\0';
1373
1374	Bstr bstrName = pszProperty;
1375	Bstr bstrValue = &pDelimiter[1];
1376	CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw()));
1377	}
1378	else
1379	{
1380	errorArgument("Invalid --nicproperty%d argument '%s'", GetOptState.uIndex, ValueUnion.psz);
1381	rc = E_FAIL;
1382	}
1383	RTStrFree(pszProperty);
1384	}
1385	else
1386	{
1387	RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for --nicproperty%d '%s'\n", GetOptState.uIndex, ValueUnion.psz);
1388	rc = E_FAIL;
1389	}
1390	}
1391	break;
1392	}
1393	case MODIFYVM_NICTYPE:
1394	{
1395	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1396	break;
1397
1398	ComPtr<INetworkAdapter> nic;
1399	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1400	ASSERT(nic);
1401
1402	if (!RTStrICmp(ValueUnion.psz, "Am79C970A"))
1403	{
1404	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1405	}
1406	else if (!RTStrICmp(ValueUnion.psz, "Am79C973"))
1407	{
1408	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1409	}
1410	#ifdef VBOX_WITH_E1000
1411	else if (!RTStrICmp(ValueUnion.psz, "82540EM"))
1412	{
1413	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1414	}
1415	else if (!RTStrICmp(ValueUnion.psz, "82543GC"))
1416	{
1417	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1418	}
1419	else if (!RTStrICmp(ValueUnion.psz, "82545EM"))
1420	{
1421	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1422	}
1423	#endif
1424	#ifdef VBOX_WITH_VIRTIO
1425	else if (!RTStrICmp(ValueUnion.psz, "virtio"))
1426	{
1427	CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1428	}
1429	#endif /* VBOX_WITH_VIRTIO */
1430	else
1431	{
1432	errorArgument("Invalid NIC type '%s' specified for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1433	rc = E_FAIL;
1434	}
1435	break;
1436	}
1437
1438	case MODIFYVM_NICSPEED:
1439	{
1440	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1441	break;
1442
1443	ComPtr<INetworkAdapter> nic;
1444	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1445	ASSERT(nic);
1446
1447	CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1448	break;
1449	}
1450
1451	case MODIFYVM_NICBOOTPRIO:
1452	{
1453	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1454	break;
1455
1456	ComPtr<INetworkAdapter> nic;
1457	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1458	ASSERT(nic);
1459
1460	/* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1461	* to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1462	* 0 for the default lowest priority).
1463	*/
1464	if (ValueUnion.u32 > 4)
1465	{
1466	errorArgument("Invalid boot priority '%u' specfied for NIC %u", ValueUnion.u32, GetOptState.uIndex);
1467	rc = E_FAIL;
1468	}
1469	else
1470	{
1471	CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1472	}
1473	break;
1474	}
1475
1476	case MODIFYVM_NICPROMISC:
1477	{
1478	NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1479	if (!RTStrICmp(ValueUnion.psz, "deny"))
1480	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1481	else if ( !RTStrICmp(ValueUnion.psz, "allow-vms")
1482	\|\| !RTStrICmp(ValueUnion.psz, "allow-network"))
1483	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1484	else if (!RTStrICmp(ValueUnion.psz, "allow-all"))
1485	enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1486	else
1487	{
1488	errorArgument("Unknown promiscuous mode policy '%s'", ValueUnion.psz);
1489	rc = E_INVALIDARG;
1490	break;
1491	}
1492
1493	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1494	break;
1495
1496	ComPtr<INetworkAdapter> nic;
1497	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1498	ASSERT(nic);
1499
1500	CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1501	break;
1502	}
1503
1504	case MODIFYVM_NICBWGROUP:
1505	{
1506	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1507	break;
1508
1509	ComPtr<INetworkAdapter> nic;
1510	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1511	ASSERT(nic);
1512
1513	if (!RTStrICmp(ValueUnion.psz, "none"))
1514	{
1515	/* Just remove the bandwidth group. */
1516	CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL));
1517	}
1518	else
1519	{
1520	ComPtr<IBandwidthControl> bwCtrl;
1521	ComPtr<IBandwidthGroup> bwGroup;
1522
1523	CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1524
1525	if (SUCCEEDED(rc))
1526	{
1527	CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
1528	if (SUCCEEDED(rc))
1529	{
1530	CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
1531	}
1532	}
1533	}
1534	break;
1535	}
1536
1537	case MODIFYVM_NIC:
1538	{
1539	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1540	break;
1541
1542	ComPtr<INetworkAdapter> nic;
1543	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1544	ASSERT(nic);
1545
1546	if (!RTStrICmp(ValueUnion.psz, "none"))
1547	{
1548	CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1549	}
1550	else if (!RTStrICmp(ValueUnion.psz, "null"))
1551	{
1552	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1553	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
1554	}
1555	else if (!RTStrICmp(ValueUnion.psz, "nat"))
1556	{
1557	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1558	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
1559	}
1560	else if ( !RTStrICmp(ValueUnion.psz, "bridged")
1561	\|\| !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1562	{
1563	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1564	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
1565	}
1566	else if (!RTStrICmp(ValueUnion.psz, "intnet"))
1567	{
1568	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1569	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
1570	}
1571	else if (!RTStrICmp(ValueUnion.psz, "hostonly"))
1572	{
1573
1574	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1575	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
1576	}
1577	else if (!RTStrICmp(ValueUnion.psz, "generic"))
1578	{
1579
1580	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1581	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
1582	}
1583	else if (!RTStrICmp(ValueUnion.psz, "natnetwork"))
1584	{
1585
1586	CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1587	CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork));
1588	}
1589	else
1590	{
1591	errorArgument("Invalid type '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1592	rc = E_FAIL;
1593	}
1594	break;
1595	}
1596
1597	case MODIFYVM_CABLECONNECTED:
1598	{
1599	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1600	break;
1601
1602	ComPtr<INetworkAdapter> nic;
1603	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1604	ASSERT(nic);
1605
1606	CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1607	break;
1608	}
1609
1610	case MODIFYVM_BRIDGEADAPTER:
1611	{
1612	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1613	break;
1614
1615	ComPtr<INetworkAdapter> nic;
1616	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1617	ASSERT(nic);
1618
1619	/* remove it? */
1620	if (!RTStrICmp(ValueUnion.psz, "none"))
1621	{
1622	CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
1623	}
1624	else
1625	{
1626	CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
1627	}
1628	break;
1629	}
1630
1631	case MODIFYVM_HOSTONLYADAPTER:
1632	{
1633	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1634	break;
1635
1636	ComPtr<INetworkAdapter> nic;
1637	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1638	ASSERT(nic);
1639
1640	/* remove it? */
1641	if (!RTStrICmp(ValueUnion.psz, "none"))
1642	{
1643	CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
1644	}
1645	else
1646	{
1647	CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
1648	}
1649	break;
1650	}
1651
1652	case MODIFYVM_INTNET:
1653	{
1654	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1655	break;
1656
1657	ComPtr<INetworkAdapter> nic;
1658	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1659	ASSERT(nic);
1660
1661	/* remove it? */
1662	if (!RTStrICmp(ValueUnion.psz, "none"))
1663	{
1664	CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
1665	}
1666	else
1667	{
1668	CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
1669	}
1670	break;
1671	}
1672
1673	case MODIFYVM_GENERICDRV:
1674	{
1675	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1676	break;
1677
1678	ComPtr<INetworkAdapter> nic;
1679	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1680	ASSERT(nic);
1681
1682	CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw()));
1683	break;
1684	}
1685
1686	case MODIFYVM_NATNETWORKNAME:
1687	{
1688	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1689	break;
1690
1691	ComPtr<INetworkAdapter> nic;
1692	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1693	ASSERT(nic);
1694
1695	CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw()));
1696	break;
1697	}
1698
1699	case MODIFYVM_NATNET:
1700	{
1701	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1702	break;
1703
1704	ComPtr<INetworkAdapter> nic;
1705	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1706	ASSERT(nic);
1707
1708	ComPtr<INATEngine> engine;
1709	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1710
1711	const char *psz = ValueUnion.psz;
1712	if (!RTStrICmp("default", psz))
1713	psz = "";
1714
1715	CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
1716	break;
1717	}
1718
1719	case MODIFYVM_NATBINDIP:
1720	{
1721	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1722	break;
1723
1724	ComPtr<INetworkAdapter> nic;
1725	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1726	ASSERT(nic);
1727
1728	ComPtr<INATEngine> engine;
1729	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1730
1731	CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
1732	break;
1733	}
1734
1735	#define ITERATE_TO_NEXT_TERM(ch) \
1736	do { \
1737	while (*ch != ',') \
1738	{ \
1739	if (*ch == 0) \
1740	{ \
1741	return errorSyntax(USAGE_MODIFYVM, \
1742	"Missing or Invalid argument to '%s'", \
1743	GetOptState.pDef->pszLong); \
1744	} \
1745	ch++; \
1746	} \
1747	*ch = '\0'; \
1748	ch++; \
1749	} while(0)
1750
1751	case MODIFYVM_NATSETTINGS:
1752	{
1753	ComPtr<INetworkAdapter> nic;
1754	ComPtr<INATEngine> engine;
1755	char *strMtu;
1756	char *strSockSnd;
1757	char *strSockRcv;
1758	char *strTcpSnd;
1759	char *strTcpRcv;
1760	char *strRaw = RTStrDup(ValueUnion.psz);
1761	char *ch = strRaw;
1762	strMtu = RTStrStrip(ch);
1763	ITERATE_TO_NEXT_TERM(ch);
1764	strSockSnd = RTStrStrip(ch);
1765	ITERATE_TO_NEXT_TERM(ch);
1766	strSockRcv = RTStrStrip(ch);
1767	ITERATE_TO_NEXT_TERM(ch);
1768	strTcpSnd = RTStrStrip(ch);
1769	ITERATE_TO_NEXT_TERM(ch);
1770	strTcpRcv = RTStrStrip(ch);
1771
1772	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1773	break;
1774
1775	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1776	ASSERT(nic);
1777
1778	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1779	CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
1780	RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
1781	break;
1782	}
1783
1784
1785	case MODIFYVM_NATPF:
1786	{
1787	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1788	break;
1789
1790	ComPtr<INetworkAdapter> nic;
1791	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1792	ASSERT(nic);
1793
1794	ComPtr<INATEngine> engine;
1795	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1796
1797	/* format name:proto:hostip:hostport:guestip:guestport*/
1798	if (RTStrCmp(ValueUnion.psz, "delete") != 0)
1799	{
1800	char *strName;
1801	char *strProto;
1802	char *strHostIp;
1803	char *strHostPort;
1804	char *strGuestIp;
1805	char *strGuestPort;
1806	char *strRaw = RTStrDup(ValueUnion.psz);
1807	char *ch = strRaw;
1808	strName = RTStrStrip(ch);
1809	ITERATE_TO_NEXT_TERM(ch);
1810	strProto = RTStrStrip(ch);
1811	ITERATE_TO_NEXT_TERM(ch);
1812	strHostIp = RTStrStrip(ch);
1813	ITERATE_TO_NEXT_TERM(ch);
1814	strHostPort = RTStrStrip(ch);
1815	ITERATE_TO_NEXT_TERM(ch);
1816	strGuestIp = RTStrStrip(ch);
1817	ITERATE_TO_NEXT_TERM(ch);
1818	strGuestPort = RTStrStrip(ch);
1819	NATProtocol_T proto;
1820	if (RTStrICmp(strProto, "udp") == 0)
1821	proto = NATProtocol_UDP;
1822	else if (RTStrICmp(strProto, "tcp") == 0)
1823	proto = NATProtocol_TCP;
1824	else
1825	{
1826	errorArgument("Invalid proto '%s' specfied for NIC %u", ValueUnion.psz, GetOptState.uIndex);
1827	rc = E_FAIL;
1828	break;
1829	}
1830	CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
1831	Bstr(strHostIp).raw(),
1832	RTStrToUInt16(strHostPort),
1833	Bstr(strGuestIp).raw(),
1834	RTStrToUInt16(strGuestPort)));
1835	}
1836	else
1837	{
1838	/* delete NAT Rule operation */
1839	int vrc;
1840	vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
1841	if (RT_FAILURE(vrc))
1842	return errorSyntax(USAGE_MODIFYVM, "Not enough parameters");
1843	CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
1844	}
1845	break;
1846	}
1847	#undef ITERATE_TO_NEXT_TERM
1848	case MODIFYVM_NATALIASMODE:
1849	{
1850	ComPtr<INetworkAdapter> nic;
1851	ComPtr<INATEngine> engine;
1852	uint32_t aliasMode = 0;
1853
1854	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1855	ASSERT(nic);
1856
1857	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1858	if (RTStrCmp(ValueUnion.psz, "default") == 0)
1859	aliasMode = 0;
1860	else
1861	{
1862	char token = (char )ValueUnion.psz;
1863	while (token)
1864	{
1865	if (RTStrNCmp(token, RT_STR_TUPLE("log")) == 0)
1866	aliasMode \|= NATAliasMode_AliasLog;
1867	else if (RTStrNCmp(token, RT_STR_TUPLE("proxyonly")) == 0)
1868	aliasMode \|= NATAliasMode_AliasProxyOnly;
1869	else if (RTStrNCmp(token, RT_STR_TUPLE("sameports")) == 0)
1870	aliasMode \|= NATAliasMode_AliasUseSamePorts;
1871	token = RTStrStr(token, ",");
1872	if (token == NULL)
1873	break;
1874	token++;
1875	}
1876	}
1877	CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
1878	break;
1879	}
1880
1881	case MODIFYVM_NATTFTPPREFIX:
1882	{
1883	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1884	break;
1885
1886	ComPtr<INetworkAdapter> nic;
1887	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1888	ASSERT(nic);
1889
1890	ComPtr<INATEngine> engine;
1891	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1892
1893	CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
1894	break;
1895	}
1896
1897	case MODIFYVM_NATTFTPFILE:
1898	{
1899	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1900	break;
1901
1902	ComPtr<INetworkAdapter> nic;
1903	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1904	ASSERT(nic);
1905
1906	ComPtr<INATEngine> engine;
1907	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1908
1909	CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
1910	break;
1911	}
1912
1913	case MODIFYVM_NATTFTPSERVER:
1914	{
1915	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1916	break;
1917
1918	ComPtr<INetworkAdapter> nic;
1919	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1920	ASSERT(nic);
1921
1922	ComPtr<INATEngine> engine;
1923	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1924
1925	CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
1926	break;
1927	}
1928	case MODIFYVM_NATDNSPASSDOMAIN:
1929	{
1930	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1931	break;
1932
1933	ComPtr<INetworkAdapter> nic;
1934	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1935	ASSERT(nic);
1936
1937	ComPtr<INATEngine> engine;
1938	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1939
1940	CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
1941	break;
1942	}
1943
1944	case MODIFYVM_NATDNSPROXY:
1945	{
1946	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1947	break;
1948
1949	ComPtr<INetworkAdapter> nic;
1950	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1951	ASSERT(nic);
1952
1953	ComPtr<INATEngine> engine;
1954	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1955
1956	CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
1957	break;
1958	}
1959
1960	case MODIFYVM_NATDNSHOSTRESOLVER:
1961	{
1962	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1963	break;
1964
1965	ComPtr<INetworkAdapter> nic;
1966	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1967	ASSERT(nic);
1968
1969	ComPtr<INATEngine> engine;
1970	CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
1971
1972	CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
1973	break;
1974	}
1975	case MODIFYVM_MACADDRESS:
1976	{
1977	if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1978	break;
1979
1980	ComPtr<INetworkAdapter> nic;
1981	CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1982	ASSERT(nic);
1983
1984	/* generate one? */
1985	if (!RTStrICmp(ValueUnion.psz, "auto"))
1986	{
1987	CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
1988	}
1989	else
1990	{
1991	CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
1992	}
1993	break;
1994	}
1995
1996	case MODIFYVM_HIDPTR:
1997	{
1998	bool fEnableUsb = false;
1999	if (!RTStrICmp(ValueUnion.psz, "ps2"))
2000	{
2001	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
2002	}
2003	else if (!RTStrICmp(ValueUnion.psz, "usb"))
2004	{
2005	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
2006	if (SUCCEEDED(rc))
2007	fEnableUsb = true;
2008	}
2009	else if (!RTStrICmp(ValueUnion.psz, "usbtablet"))
2010	{
2011	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
2012	if (SUCCEEDED(rc))
2013	fEnableUsb = true;
2014	}
2015	else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch"))
2016	{
2017	CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
2018	if (SUCCEEDED(rc))
2019	fEnableUsb = true;
2020	}
2021	else
2022	{
2023	errorArgument("Invalid type '%s' specfied for pointing device", ValueUnion.psz);
2024	rc = E_FAIL;
2025	}
2026	if (fEnableUsb)
2027	{
2028	/* Make sure either the OHCI or xHCI controller is enabled. */
2029	ULONG cOhciCtrls = 0;
2030	ULONG cXhciCtrls = 0;
2031	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2032	if (SUCCEEDED(rc)) {
2033	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2034	if ( SUCCEEDED(rc)
2035	&& cOhciCtrls + cXhciCtrls == 0)
2036	{
2037	/* If there's nothing, enable OHCI (always available). */
2038	ComPtr<IUSBController> UsbCtl;
2039	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2040	UsbCtl.asOutParam()));
2041	}
2042	}
2043	}
2044	break;
2045	}
2046
2047	case MODIFYVM_HIDKBD:
2048	{
2049	bool fEnableUsb = false;
2050	if (!RTStrICmp(ValueUnion.psz, "ps2"))
2051	{
2052	CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
2053	}
2054	else if (!RTStrICmp(ValueUnion.psz, "usb"))
2055	{
2056	CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
2057	if (SUCCEEDED(rc))
2058	fEnableUsb = true;
2059	}
2060	else
2061	{
2062	errorArgument("Invalid type '%s' specfied for keyboard", ValueUnion.psz);
2063	rc = E_FAIL;
2064	}
2065	if (fEnableUsb)
2066	{
2067	/* Make sure either the OHCI or xHCI controller is enabled. */
2068	ULONG cOhciCtrls = 0;
2069	ULONG cXhciCtrls = 0;
2070	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2071	if (SUCCEEDED(rc)) {
2072	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2073	if ( SUCCEEDED(rc)
2074	&& cOhciCtrls + cXhciCtrls == 0)
2075	{
2076	/* If there's nothing, enable OHCI (always available). */
2077	ComPtr<IUSBController> UsbCtl;
2078	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2079	UsbCtl.asOutParam()));
2080	}
2081	}
2082	}
2083	break;
2084	}
2085
2086	case MODIFYVM_UARTMODE:
2087	{
2088	ComPtr<ISerialPort> uart;
2089
2090	CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2091	ASSERT(uart);
2092
2093	if (!RTStrICmp(ValueUnion.psz, "disconnected"))
2094	{
2095	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2096	}
2097	else if ( !RTStrICmp(ValueUnion.psz, "server")
2098	\|\| !RTStrICmp(ValueUnion.psz, "client")
2099	\|\| !RTStrICmp(ValueUnion.psz, "tcpserver")
2100	\|\| !RTStrICmp(ValueUnion.psz, "tcpclient")
2101	\|\| !RTStrICmp(ValueUnion.psz, "file"))
2102	{
2103	const char *pszMode = ValueUnion.psz;
2104
2105	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2106	if (RT_FAILURE(vrc))
2107	return errorSyntax(USAGE_MODIFYVM,
2108	"Missing or Invalid argument to '%s'",
2109	GetOptState.pDef->pszLong);
2110
2111	CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2112
2113	if (!RTStrICmp(pszMode, "server"))
2114	{
2115	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2116	CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2117	}
2118	else if (!RTStrICmp(pszMode, "client"))
2119	{
2120	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2121	CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2122	}
2123	else if (!RTStrICmp(pszMode, "tcpserver"))
2124	{
2125	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2126	CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2127	}
2128	else if (!RTStrICmp(pszMode, "tcpclient"))
2129	{
2130	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2131	CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2132	}
2133	else if (!RTStrICmp(pszMode, "file"))
2134	{
2135	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
2136	}
2137	}
2138	else
2139	{
2140	CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2141	CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
2142	}
2143	break;
2144	}
2145
2146	case MODIFYVM_UART:
2147	{
2148	ComPtr<ISerialPort> uart;
2149
2150	CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2151	ASSERT(uart);
2152
2153	if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
2154	CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
2155	else
2156	{
2157	const char *pszIOBase = ValueUnion.psz;
2158	uint32_t uVal = 0;
2159
2160	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
2161	if (RT_FAILURE(vrc))
2162	return errorSyntax(USAGE_MODIFYVM,
2163	"Missing or Invalid argument to '%s'",
2164	GetOptState.pDef->pszLong);
2165
2166	CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
2167
2168	vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2169	if (vrc != VINF_SUCCESS \|\| uVal == 0)
2170	return errorArgument("Error parsing UART I/O base '%s'", pszIOBase);
2171	CHECK_ERROR(uart, COMSETTER(IOBase)(uVal));
2172
2173	CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
2174	}
2175	break;
2176	}
2177
2178	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_WINDOWS)
2179	case MODIFYVM_LPTMODE:
2180	{
2181	ComPtr<IParallelPort> lpt;
2182
2183	CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2184	ASSERT(lpt);
2185
2186	CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2187	break;
2188	}
2189
2190	case MODIFYVM_LPT:
2191	{
2192	ComPtr<IParallelPort> lpt;
2193
2194	CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2195	ASSERT(lpt);
2196
2197	if (!RTStrICmp(ValueUnion.psz, "off") \|\| !RTStrICmp(ValueUnion.psz, "disable"))
2198	CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE));
2199	else
2200	{
2201	const char *pszIOBase = ValueUnion.psz;
2202	uint32_t uVal = 0;
2203
2204	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT;
2205	if (RT_FAILURE(vrc))
2206	return errorSyntax(USAGE_MODIFYVM,
2207	"Missing or Invalid argument to '%s'",
2208	GetOptState.pDef->pszLong);
2209
2210	CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32));
2211
2212	vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2213	if (vrc != VINF_SUCCESS \|\| uVal == 0)
2214	return errorArgument("Error parsing LPT I/O base '%s'", pszIOBase);
2215	CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
2216
2217	CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE));
2218	}
2219	break;
2220	}
2221	#endif
2222
2223	case MODIFYVM_GUESTMEMORYBALLOON:
2224	{
2225	CHECK_ERROR(sessionMachine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
2226	break;
2227	}
2228
2229	case MODIFYVM_AUDIOCONTROLLER:
2230	{
2231	ComPtr<IAudioAdapter> audioAdapter;
2232	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2233	ASSERT(audioAdapter);
2234
2235	if (!RTStrICmp(ValueUnion.psz, "sb16"))
2236	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
2237	else if (!RTStrICmp(ValueUnion.psz, "ac97"))
2238	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
2239	else if (!RTStrICmp(ValueUnion.psz, "hda"))
2240	CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
2241	else
2242	{
2243	errorArgument("Invalid --audiocontroller argument '%s'", ValueUnion.psz);
2244	rc = E_FAIL;
2245	}
2246	break;
2247	}
2248
2249	case MODIFYVM_AUDIOCODEC:
2250	{
2251	ComPtr<IAudioAdapter> audioAdapter;
2252	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2253	ASSERT(audioAdapter);
2254
2255	if (!RTStrICmp(ValueUnion.psz, "sb16"))
2256	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_SB16));
2257	else if (!RTStrICmp(ValueUnion.psz, "stac9700"))
2258	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9700));
2259	else if (!RTStrICmp(ValueUnion.psz, "ad1980"))
2260	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_AD1980));
2261	else if (!RTStrICmp(ValueUnion.psz, "stac9221"))
2262	CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9221));
2263	else
2264	{
2265	errorArgument("Invalid --audiocodec argument '%s'", ValueUnion.psz);
2266	rc = E_FAIL;
2267	}
2268	break;
2269	}
2270
2271	case MODIFYVM_AUDIO:
2272	{
2273	ComPtr<IAudioAdapter> audioAdapter;
2274	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2275	ASSERT(audioAdapter);
2276
2277	/* disable? */
2278	if (!RTStrICmp(ValueUnion.psz, "none"))
2279	{
2280	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(false));
2281	}
2282	else if (!RTStrICmp(ValueUnion.psz, "null"))
2283	{
2284	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
2285	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2286	}
2287	#ifdef RT_OS_WINDOWS
2288	#ifdef VBOX_WITH_WINMM
2289	else if (!RTStrICmp(ValueUnion.psz, "winmm"))
2290	{
2291	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
2292	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2293	}
2294	#endif
2295	else if (!RTStrICmp(ValueUnion.psz, "dsound"))
2296	{
2297	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
2298	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2299	}
2300	#endif /* RT_OS_WINDOWS */
2301	#ifdef VBOX_WITH_AUDIO_OSS
2302	else if (!RTStrICmp(ValueUnion.psz, "oss"))
2303	{
2304	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2305	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2306	}
2307	#endif
2308	#ifdef VBOX_WITH_AUDIO_ALSA
2309	else if (!RTStrICmp(ValueUnion.psz, "alsa"))
2310	{
2311	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
2312	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2313	}
2314	#endif
2315	#ifdef VBOX_WITH_AUDIO_PULSE
2316	else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2317	{
2318	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2319	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2320	}
2321	#endif
2322	#ifdef RT_OS_DARWIN
2323	else if (!RTStrICmp(ValueUnion.psz, "coreaudio"))
2324	{
2325	CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
2326	CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(true));
2327	}
2328	#endif /* !RT_OS_DARWIN */
2329	else
2330	{
2331	errorArgument("Invalid --audio argument '%s'", ValueUnion.psz);
2332	rc = E_FAIL;
2333	}
2334	break;
2335	}
2336
2337	case MODIFYVM_AUDIOIN:
2338	{
2339	ComPtr<IAudioAdapter> audioAdapter;
2340	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2341	ASSERT(audioAdapter);
2342
2343	CHECK_ERROR(audioAdapter, COMSETTER(EnabledIn)(ValueUnion.f));
2344	break;
2345	}
2346
2347	case MODIFYVM_AUDIOOUT:
2348	{
2349	ComPtr<IAudioAdapter> audioAdapter;
2350	sessionMachine->COMGETTER(AudioAdapter)(audioAdapter.asOutParam());
2351	ASSERT(audioAdapter);
2352
2353	CHECK_ERROR(audioAdapter, COMSETTER(EnabledIn)(ValueUnion.f));
2354	break;
2355	}
2356
2357	case MODIFYVM_CLIPBOARD:
2358	{
2359	ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */
2360	if (!RTStrICmp(ValueUnion.psz, "disabled"))
2361	mode = ClipboardMode_Disabled;
2362	else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2363	mode = ClipboardMode_HostToGuest;
2364	else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2365	mode = ClipboardMode_GuestToHost;
2366	else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2367	mode = ClipboardMode_Bidirectional;
2368	else
2369	{
2370	errorArgument("Invalid --clipboard argument '%s'", ValueUnion.psz);
2371	rc = E_FAIL;
2372	}
2373	if (SUCCEEDED(rc))
2374	{
2375	CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode));
2376	}
2377	break;
2378	}
2379
2380	case MODIFYVM_DRAGANDDROP:
2381	{
2382	DnDMode_T mode = DnDMode_Disabled; /* Shut up MSC */
2383	if (!RTStrICmp(ValueUnion.psz, "disabled"))
2384	mode = DnDMode_Disabled;
2385	else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2386	mode = DnDMode_HostToGuest;
2387	else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2388	mode = DnDMode_GuestToHost;
2389	else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2390	mode = DnDMode_Bidirectional;
2391	else
2392	{
2393	errorArgument("Invalid --draganddrop argument '%s'", ValueUnion.psz);
2394	rc = E_FAIL;
2395	}
2396	if (SUCCEEDED(rc))
2397	{
2398	CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode));
2399	}
2400	break;
2401	}
2402
2403	case MODIFYVM_VRDE_EXTPACK:
2404	{
2405	ComPtr<IVRDEServer> vrdeServer;
2406	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2407	ASSERT(vrdeServer);
2408
2409	if (vrdeServer)
2410	{
2411	if (RTStrICmp(ValueUnion.psz, "default") != 0)
2412	{
2413	Bstr bstr(ValueUnion.psz);
2414	CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
2415	}
2416	else
2417	CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
2418	}
2419	break;
2420	}
2421
2422	case MODIFYVM_VRDEPROPERTY:
2423	{
2424	ComPtr<IVRDEServer> vrdeServer;
2425	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2426	ASSERT(vrdeServer);
2427
2428	if (vrdeServer)
2429	{
2430	/* Parse 'name=value' */
2431	char *pszProperty = RTStrDup(ValueUnion.psz);
2432	if (pszProperty)
2433	{
2434	char *pDelimiter = strchr(pszProperty, '=');
2435	if (pDelimiter)
2436	{
2437	*pDelimiter = '\0';
2438
2439	Bstr bstrName = pszProperty;
2440	Bstr bstrValue = &pDelimiter[1];
2441	CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
2442	}
2443	else
2444	{
2445	RTStrFree(pszProperty);
2446
2447	errorArgument("Invalid --vrdeproperty argument '%s'", ValueUnion.psz);
2448	rc = E_FAIL;
2449	break;
2450	}
2451	RTStrFree(pszProperty);
2452	}
2453	else
2454	{
2455	RTStrmPrintf(g_pStdErr, "Error: Failed to allocate memory for VRDE property '%s'\n", ValueUnion.psz);
2456	rc = E_FAIL;
2457	}
2458	}
2459	break;
2460	}
2461
2462	case MODIFYVM_VRDPPORT:
2463	vrdeWarningDeprecatedOption("port");
2464	RT_FALL_THRU();
2465
2466	case MODIFYVM_VRDEPORT:
2467	{
2468	ComPtr<IVRDEServer> vrdeServer;
2469	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2470	ASSERT(vrdeServer);
2471
2472	if (!RTStrICmp(ValueUnion.psz, "default"))
2473	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
2474	else
2475	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
2476	break;
2477	}
2478
2479	case MODIFYVM_VRDPADDRESS:
2480	vrdeWarningDeprecatedOption("address");
2481	RT_FALL_THRU();
2482
2483	case MODIFYVM_VRDEADDRESS:
2484	{
2485	ComPtr<IVRDEServer> vrdeServer;
2486	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2487	ASSERT(vrdeServer);
2488
2489	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw()));
2490	break;
2491	}
2492
2493	case MODIFYVM_VRDPAUTHTYPE:
2494	vrdeWarningDeprecatedOption("authtype");
2495	RT_FALL_THRU();
2496	case MODIFYVM_VRDEAUTHTYPE:
2497	{
2498	ComPtr<IVRDEServer> vrdeServer;
2499	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2500	ASSERT(vrdeServer);
2501
2502	if (!RTStrICmp(ValueUnion.psz, "null"))
2503	{
2504	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
2505	}
2506	else if (!RTStrICmp(ValueUnion.psz, "external"))
2507	{
2508	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
2509	}
2510	else if (!RTStrICmp(ValueUnion.psz, "guest"))
2511	{
2512	CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
2513	}
2514	else
2515	{
2516	errorArgument("Invalid --vrdeauthtype argument '%s'", ValueUnion.psz);
2517	rc = E_FAIL;
2518	}
2519	break;
2520	}
2521
2522	case MODIFYVM_VRDEAUTHLIBRARY:
2523	{
2524	ComPtr<IVRDEServer> vrdeServer;
2525	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2526	ASSERT(vrdeServer);
2527
2528	if (vrdeServer)
2529	{
2530	if (RTStrICmp(ValueUnion.psz, "default") != 0)
2531	{
2532	Bstr bstr(ValueUnion.psz);
2533	CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw()));
2534	}
2535	else
2536	CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
2537	}
2538	break;
2539	}
2540
2541	case MODIFYVM_VRDPMULTICON:
2542	vrdeWarningDeprecatedOption("multicon");
2543	RT_FALL_THRU();
2544	case MODIFYVM_VRDEMULTICON:
2545	{
2546	ComPtr<IVRDEServer> vrdeServer;
2547	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2548	ASSERT(vrdeServer);
2549
2550	CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
2551	break;
2552	}
2553
2554	case MODIFYVM_VRDPREUSECON:
2555	vrdeWarningDeprecatedOption("reusecon");
2556	RT_FALL_THRU();
2557	case MODIFYVM_VRDEREUSECON:
2558	{
2559	ComPtr<IVRDEServer> vrdeServer;
2560	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2561	ASSERT(vrdeServer);
2562
2563	CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
2564	break;
2565	}
2566
2567	case MODIFYVM_VRDPVIDEOCHANNEL:
2568	vrdeWarningDeprecatedOption("videochannel");
2569	RT_FALL_THRU();
2570	case MODIFYVM_VRDEVIDEOCHANNEL:
2571	{
2572	ComPtr<IVRDEServer> vrdeServer;
2573	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2574	ASSERT(vrdeServer);
2575
2576	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
2577	ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
2578	break;
2579	}
2580
2581	case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
2582	vrdeWarningDeprecatedOption("videochannelquality");
2583	RT_FALL_THRU();
2584	case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
2585	{
2586	ComPtr<IVRDEServer> vrdeServer;
2587	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2588	ASSERT(vrdeServer);
2589
2590	CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
2591	Bstr(ValueUnion.psz).raw()));
2592	break;
2593	}
2594
2595	case MODIFYVM_VRDP:
2596	vrdeWarningDeprecatedOption("");
2597	RT_FALL_THRU();
2598	case MODIFYVM_VRDE:
2599	{
2600	ComPtr<IVRDEServer> vrdeServer;
2601	sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2602	ASSERT(vrdeServer);
2603
2604	CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
2605	break;
2606	}
2607
2608	case MODIFYVM_USBRENAME:
2609	{
2610	const char *pszName = ValueUnion.psz;
2611	int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2612	if (RT_FAILURE(vrc))
2613	return errorSyntax(USAGE_MODIFYVM,
2614	"Missing or Invalid argument to '%s'",
2615	GetOptState.pDef->pszLong);
2616	const char *pszNewName = ValueUnion.psz;
2617
2618	SafeIfaceArray<IUSBController> ctrls;
2619	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2620	bool fRenamed = false;
2621	for (size_t i = 0; i < ctrls.size(); i++)
2622	{
2623	ComPtr<IUSBController> pCtrl = ctrls[i];
2624	Bstr bstrName;
2625	CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam()));
2626	if (bstrName == pszName)
2627	{
2628	bstrName = pszNewName;
2629	CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw()));
2630	fRenamed = true;
2631	}
2632	}
2633	if (!fRenamed)
2634	{
2635	errorArgument("Invalid --usbrename parameters, nothing renamed");
2636	rc = E_FAIL;
2637	}
2638	break;
2639	}
2640
2641	case MODIFYVM_USBXHCI:
2642	{
2643	ULONG cXhciCtrls = 0;
2644	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2645	if (SUCCEEDED(rc))
2646	{
2647	if (!cXhciCtrls && ValueUnion.f)
2648	{
2649	ComPtr<IUSBController> UsbCtl;
2650	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI,
2651	UsbCtl.asOutParam()));
2652	}
2653	else if (cXhciCtrls && !ValueUnion.f)
2654	{
2655	SafeIfaceArray<IUSBController> ctrls;
2656	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2657	for (size_t i = 0; i < ctrls.size(); i++)
2658	{
2659	ComPtr<IUSBController> pCtrl = ctrls[i];
2660	USBControllerType_T enmType;
2661	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2662	if (enmType == USBControllerType_XHCI)
2663	{
2664	Bstr ctrlName;
2665	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2666	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2667	}
2668	}
2669	}
2670	}
2671	break;
2672	}
2673
2674	case MODIFYVM_USBEHCI:
2675	{
2676	ULONG cEhciCtrls = 0;
2677	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
2678	if (SUCCEEDED(rc))
2679	{
2680	if (!cEhciCtrls && ValueUnion.f)
2681	{
2682	ComPtr<IUSBController> UsbCtl;
2683	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
2684	UsbCtl.asOutParam()));
2685	}
2686	else if (cEhciCtrls && !ValueUnion.f)
2687	{
2688	SafeIfaceArray<IUSBController> ctrls;
2689	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2690	for (size_t i = 0; i < ctrls.size(); i++)
2691	{
2692	ComPtr<IUSBController> pCtrl = ctrls[i];
2693	USBControllerType_T enmType;
2694	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2695	if (enmType == USBControllerType_EHCI)
2696	{
2697	Bstr ctrlName;
2698	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2699	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2700	}
2701	}
2702	}
2703	}
2704	break;
2705	}
2706
2707	case MODIFYVM_USBOHCI:
2708	{
2709	ULONG cOhciCtrls = 0;
2710	rc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2711	if (SUCCEEDED(rc))
2712	{
2713	if (!cOhciCtrls && ValueUnion.f)
2714	{
2715	ComPtr<IUSBController> UsbCtl;
2716	CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2717	UsbCtl.asOutParam()));
2718	}
2719	else if (cOhciCtrls && !ValueUnion.f)
2720	{
2721	SafeIfaceArray<IUSBController> ctrls;
2722	CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
2723	for (size_t i = 0; i < ctrls.size(); i++)
2724	{
2725	ComPtr<IUSBController> pCtrl = ctrls[i];
2726	USBControllerType_T enmType;
2727	CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
2728	if (enmType == USBControllerType_OHCI)
2729	{
2730	Bstr ctrlName;
2731	CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
2732	CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
2733	}
2734	}
2735	}
2736	}
2737	break;
2738	}
2739
2740	case MODIFYVM_SNAPSHOTFOLDER:
2741	{
2742	if (!RTStrICmp(ValueUnion.psz, "default"))
2743	CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr().raw()));
2744	else
2745	CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
2746	break;
2747	}
2748
2749	case MODIFYVM_TELEPORTER_ENABLED:
2750	{
2751	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
2752	break;
2753	}
2754
2755	case MODIFYVM_TELEPORTER_PORT:
2756	{
2757	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPort)(ValueUnion.u32));
2758	break;
2759	}
2760
2761	case MODIFYVM_TELEPORTER_ADDRESS:
2762	{
2763	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
2764	break;
2765	}
2766
2767	case MODIFYVM_TELEPORTER_PASSWORD:
2768	{
2769	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
2770	break;
2771	}
2772
2773	case MODIFYVM_TELEPORTER_PASSWORD_FILE:
2774	{
2775	Utf8Str password;
2776	RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
2777	if (rcExit != RTEXITCODE_SUCCESS)
2778	rc = E_FAIL;
2779	else
2780	CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
2781	break;
2782	}
2783
2784	case MODIFYVM_TRACING_ENABLED:
2785	{
2786	CHECK_ERROR(sessionMachine, COMSETTER(TracingEnabled)(ValueUnion.f));
2787	break;
2788	}
2789
2790	case MODIFYVM_TRACING_CONFIG:
2791	{
2792	CHECK_ERROR(sessionMachine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
2793	break;
2794	}
2795
2796	case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
2797	{
2798	CHECK_ERROR(sessionMachine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
2799	break;
2800	}
2801
2802	case MODIFYVM_FAULT_TOLERANCE:
2803	{
2804	if (!RTStrICmp(ValueUnion.psz, "master"))
2805	{
2806	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Master)));
2807	}
2808	else
2809	if (!RTStrICmp(ValueUnion.psz, "standby"))
2810	{
2811	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceState(FaultToleranceState_Standby)));
2812	}
2813	else
2814	{
2815	errorArgument("Invalid --faulttolerance argument '%s'", ValueUnion.psz);
2816	rc = E_FAIL;
2817	}
2818	break;
2819	}
2820
2821	case MODIFYVM_FAULT_TOLERANCE_ADDRESS:
2822	{
2823	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceAddress)(Bstr(ValueUnion.psz).raw()));
2824	break;
2825	}
2826
2827	case MODIFYVM_FAULT_TOLERANCE_PORT:
2828	{
2829	CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePort)(ValueUnion.u32));
2830	break;
2831	}
2832
2833	case MODIFYVM_FAULT_TOLERANCE_PASSWORD:
2834	{
2835	CHECK_ERROR(sessionMachine, COMSETTER(FaultTolerancePassword)(Bstr(ValueUnion.psz).raw()));
2836	break;
2837	}
2838
2839	case MODIFYVM_FAULT_TOLERANCE_SYNC_INTERVAL:
2840	{
2841	CHECK_ERROR(sessionMachine, COMSETTER(FaultToleranceSyncInterval)(ValueUnion.u32));
2842	break;
2843	}
2844
2845	case MODIFYVM_HARDWARE_UUID:
2846	{
2847	CHECK_ERROR(sessionMachine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
2848	break;
2849	}
2850
2851	case MODIFYVM_HPET:
2852	{
2853	CHECK_ERROR(sessionMachine, COMSETTER(HPETEnabled)(ValueUnion.f));
2854	break;
2855	}
2856
2857	case MODIFYVM_IOCACHE:
2858	{
2859	CHECK_ERROR(sessionMachine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
2860	break;
2861	}
2862
2863	case MODIFYVM_IOCACHESIZE:
2864	{
2865	CHECK_ERROR(sessionMachine, COMSETTER(IOCacheSize)(ValueUnion.u32));
2866	break;
2867	}
2868
2869	case MODIFYVM_CHIPSET:
2870	{
2871	if (!RTStrICmp(ValueUnion.psz, "piix3"))
2872	{
2873	CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
2874	}
2875	else if (!RTStrICmp(ValueUnion.psz, "ich9"))
2876	{
2877	CHECK_ERROR(sessionMachine, COMSETTER(ChipsetType)(ChipsetType_ICH9));
2878	BOOL fIoApic = FALSE;
2879	CHECK_ERROR(biosSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
2880	if (!fIoApic)
2881	{
2882	RTStrmPrintf(g_pStdErr, "* I/O APIC must be enabled for ICH9, enabling. *\n");
2883	CHECK_ERROR(biosSettings, COMSETTER(IOAPICEnabled)(TRUE));
2884	}
2885	}
2886	else
2887	{
2888	errorArgument("Invalid --chipset argument '%s' (valid: piix3,ich9)", ValueUnion.psz);
2889	rc = E_FAIL;
2890	}
2891	break;
2892	}
2893	#ifdef VBOX_WITH_VIDEOREC
2894	case MODIFYVM_VIDEOCAP:
2895	{
2896	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureEnabled)(ValueUnion.f));
2897	break;
2898	}
2899	case MODIFYVM_VIDEOCAP_SCREENS:
2900	{
2901	ULONG cMonitors = 64;
2902	CHECK_ERROR(sessionMachine, COMGETTER(MonitorCount)(&cMonitors));
2903	com::SafeArray<BOOL> screens(cMonitors);
2904	if (parseScreens(ValueUnion.psz, &screens))
2905	{
2906	errorArgument("Invalid list of screens specified\n");
2907	rc = E_FAIL;
2908	break;
2909	}
2910	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureScreens)(ComSafeArrayAsInParam(screens)));
2911	break;
2912	}
2913	case MODIFYVM_VIDEOCAP_FILENAME:
2914	{
2915	Bstr bstr;
2916	/* empty string will fall through, leaving bstr empty */
2917	if (*ValueUnion.psz)
2918	{
2919	char szVCFileAbs[RTPATH_MAX] = "";
2920	int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs));
2921	if (RT_FAILURE(vrc))
2922	{
2923	errorArgument("Cannot convert filename \"%s\" to absolute path\n", ValueUnion.psz);
2924	rc = E_FAIL;
2925	break;
2926	}
2927	bstr = szVCFileAbs;
2928	}
2929	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureFile)(bstr.raw()));
2930	break;
2931	}
2932	case MODIFYVM_VIDEOCAP_WIDTH:
2933	{
2934	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureWidth)(ValueUnion.u32));
2935	break;
2936	}
2937	case MODIFYVM_VIDEOCAP_HEIGHT:
2938	{
2939	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureHeight)(ValueUnion.u32));
2940	break;
2941	}
2942	case MODIFYVM_VIDEOCAP_RES:
2943	{
2944	uint32_t uWidth = 0;
2945	char *pszNext;
2946	int vrc = RTStrToUInt32Ex(ValueUnion.psz, &pszNext, 0, &uWidth);
2947	if (RT_FAILURE(vrc) \|\| vrc != VWRN_TRAILING_CHARS \|\| !pszNext \|\| *pszNext != 'x')
2948	{
2949	errorArgument("Error parsing geomtry '%s' (expected <width>x<height>)", ValueUnion.psz);
2950	rc = E_FAIL;
2951	break;
2952	}
2953	uint32_t uHeight = 0;
2954	vrc = RTStrToUInt32Ex(pszNext+1, NULL, 0, &uHeight);
2955	if (vrc != VINF_SUCCESS)
2956	{
2957	errorArgument("Error parsing geomtry '%s' (expected <width>x<height>)", ValueUnion.psz);
2958	rc = E_FAIL;
2959	break;
2960	}
2961	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureWidth)(uWidth));
2962	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureHeight)(uHeight));
2963	break;
2964	}
2965	case MODIFYVM_VIDEOCAP_RATE:
2966	{
2967	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureRate)(ValueUnion.u32));
2968	break;
2969	}
2970	case MODIFYVM_VIDEOCAP_FPS:
2971	{
2972	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureFPS)(ValueUnion.u32));
2973	break;
2974	}
2975	case MODIFYVM_VIDEOCAP_MAXTIME:
2976	{
2977	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureMaxTime)(ValueUnion.u32));
2978	break;
2979	}
2980	case MODIFYVM_VIDEOCAP_MAXSIZE:
2981	{
2982	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureMaxFileSize)(ValueUnion.u32));
2983	break;
2984	}
2985	case MODIFYVM_VIDEOCAP_OPTIONS:
2986	{
2987	Bstr bstr(ValueUnion.psz);
2988	CHECK_ERROR(sessionMachine, COMSETTER(VideoCaptureOptions)(bstr.raw()));
2989	break;
2990	}
2991	#endif
2992	case MODIFYVM_AUTOSTART_ENABLED:
2993	{
2994	CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(ValueUnion.f));
2995	break;
2996	}
2997
2998	case MODIFYVM_AUTOSTART_DELAY:
2999	{
3000	CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(ValueUnion.u32));
3001	break;
3002	}
3003
3004	case MODIFYVM_AUTOSTOP_TYPE:
3005	{
3006	AutostopType_T enmAutostopType = AutostopType_Disabled;
3007
3008	if (!RTStrICmp(ValueUnion.psz, "disabled"))
3009	enmAutostopType = AutostopType_Disabled;
3010	else if (!RTStrICmp(ValueUnion.psz, "savestate"))
3011	enmAutostopType = AutostopType_SaveState;
3012	else if (!RTStrICmp(ValueUnion.psz, "poweroff"))
3013	enmAutostopType = AutostopType_PowerOff;
3014	else if (!RTStrICmp(ValueUnion.psz, "acpishutdown"))
3015	enmAutostopType = AutostopType_AcpiShutdown;
3016	else
3017	{
3018	errorArgument("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)", ValueUnion.psz);
3019	rc = E_FAIL;
3020	}
3021
3022	if (SUCCEEDED(rc))
3023	CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType));
3024	break;
3025	}
3026	#ifdef VBOX_WITH_PCI_PASSTHROUGH
3027	case MODIFYVM_ATTACH_PCI:
3028	{
3029	const char* pAt = strchr(ValueUnion.psz, '@');
3030	int32_t iHostAddr, iGuestAddr;
3031
3032	iHostAddr = parsePci(ValueUnion.psz);
3033	iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
3034
3035	if (iHostAddr == -1 \|\| iGuestAddr == -1)
3036	{
3037	errorArgument("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')", ValueUnion.psz);
3038	rc = E_FAIL;
3039	}
3040	else
3041	{
3042	CHECK_ERROR(sessionMachine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
3043	}
3044
3045	break;
3046	}
3047	case MODIFYVM_DETACH_PCI:
3048	{
3049	int32_t iHostAddr;
3050
3051	iHostAddr = parsePci(ValueUnion.psz);
3052	if (iHostAddr == -1)
3053	{
3054	errorArgument("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')", ValueUnion.psz);
3055	rc = E_FAIL;
3056	}
3057	else
3058	{
3059	CHECK_ERROR(sessionMachine, DetachHostPCIDevice(iHostAddr));
3060	}
3061
3062	break;
3063	}
3064	#endif
3065
3066	#ifdef VBOX_WITH_USB_CARDREADER
3067	case MODIFYVM_USBCARDREADER:
3068	{
3069	CHECK_ERROR(sessionMachine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f));
3070	break;
3071	}
3072	#endif /* VBOX_WITH_USB_CARDREADER */
3073
3074	case MODIFYVM_DEFAULTFRONTEND:
3075	{
3076	Bstr bstr(ValueUnion.psz);
3077	if (bstr == "default")
3078	bstr = Bstr::Empty;
3079	CHECK_ERROR(sessionMachine, COMSETTER(DefaultFrontend)(bstr.raw()));
3080	break;
3081	}
3082
3083	default:
3084	{
3085	errorGetOpt(USAGE_MODIFYVM, c, &ValueUnion);
3086	rc = E_FAIL;
3087	break;
3088	}
3089	}
3090	}
3091
3092	/* commit changes */
3093	if (SUCCEEDED(rc))
3094	CHECK_ERROR(sessionMachine, SaveSettings());
3095
3096	/* it's important to always close sessions */
3097	a->session->UnlockMachine();
3098
3099	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3100	}
3101
3102	#endif /* !VBOX_ONLY_DOCS */

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: