VirtualBox

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

Last change on this file was 103150, checked in by vboxsync, 3 months ago

Frontends: Some warning fixes about externally visible functions which should be static, bugref:3409
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 169.8 KB
Line 
1/* $Id: VBoxManageModifyVM.cpp 103150 2024-01-31 15:41:58Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of modifyvm command.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include <VBox/com/com.h>
33#include <VBox/com/array.h>
34#include <VBox/com/ErrorInfo.h>
35#include <VBox/com/errorprint.h>
36#include <VBox/com/VirtualBox.h>
37
38#include <iprt/cidr.h>
39#include <iprt/ctype.h>
40#include <iprt/file.h>
41#include <iprt/param.h>
42#include <iprt/path.h>
43#include <iprt/stream.h>
44#include <iprt/string.h>
45#include <iprt/getopt.h>
46#include <VBox/log.h>
47#include "VBoxManage.h"
48#include "VBoxManageUtils.h"
49
50DECLARE_TRANSLATION_CONTEXT(ModifyVM);
51
52using namespace com;
53/** @todo refine this after HDD changes; MSC 8.0/64 has trouble with handleModifyVM. */
54#if defined(_MSC_VER)
55# pragma optimize("g", off)
56# if _MSC_VER < RT_MSC_VER_VC120
57# pragma warning(disable:4748)
58# endif
59#endif
60
61enum
62{
63 MODIFYVM_NAME = 1000,
64 MODIFYVM_GROUPS,
65 MODIFYVM_DESCRIPTION,
66 MODIFYVM_OSTYPE,
67 MODIFYVM_ICONFILE,
68 MODIFYVM_MEMORY,
69 MODIFYVM_PAGEFUSION,
70 MODIFYVM_VRAM,
71 MODIFYVM_FIRMWARE,
72 MODIFYVM_ACPI,
73 MODIFYVM_IOAPIC,
74 MODIFYVM_CPUID_PORTABILITY,
75 MODIFYVM_PARAVIRTPROVIDER,
76 MODIFYVM_PARAVIRTDEBUG,
77 MODIFYVM_CPUS,
78 MODIFYVM_CPUHOTPLUG,
79 MODIFYVM_CPU_PROFILE,
80 MODIFYVM_PLUGCPU,
81 MODIFYVM_UNPLUGCPU,
82 MODIFYVM_GRAPHICSCONTROLLER,
83 MODIFYVM_MONITORCOUNT,
84 MODIFYVM_ACCELERATE3D,
85#ifdef VBOX_WITH_VIDEOHWACCEL
86 MODIFYVM_ACCELERATE2DVIDEO,
87#endif
88 /*
89 * Firmware-specific stuff.
90 */
91 MODIFYVM_FWLOGOFADEIN,
92 MODIFYVM_FWLOGOFADEOUT,
93 MODIFYVM_FWLOGODISPLAYTIME,
94 MODIFYVM_FWLOGOIMAGEPATH,
95 MODIFYVM_FWBOOTMENU,
96 MODIFYVM_FWAPIC,
97 MODIFYVM_FWSYSTEMTIMEOFFSET,
98 MODIFYVM_FWPXEDEBUG,
99 MODIFYVM_SYSTEMUUIDLE,
100 MODIFYVM_FWAUTOSERIALNUMGEN,
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#ifdef VBOX_WITH_CLOUD_NET
127 MODIFYVM_CLOUDNET,
128#endif /* VBOX_WITH_CLOUD_NET */
129 MODIFYVM_HOSTONLYADAPTER,
130#ifdef VBOX_WITH_VMNET
131 MODIFYVM_HOSTONLYNET,
132#endif /* VBOX_WITH_VMNET */
133 MODIFYVM_INTNET,
134 MODIFYVM_GENERICDRV,
135 MODIFYVM_NATNETWORKNAME,
136 MODIFYVM_NATNET,
137 MODIFYVM_NATBINDIP,
138 MODIFYVM_NATSETTINGS,
139 MODIFYVM_NATPF,
140 MODIFYVM_NATALIASMODE,
141 MODIFYVM_NATTFTPPREFIX,
142 MODIFYVM_NATTFTPFILE,
143 MODIFYVM_NATTFTPSERVER,
144 MODIFYVM_NATDNSPASSDOMAIN,
145 MODIFYVM_NATDNSPROXY,
146 MODIFYVM_NATDNSHOSTRESOLVER,
147 MODIFYVM_NATLOCALHOSTREACHABLE,
148 MODIFYVM_MACADDRESS,
149 MODIFYVM_HIDPTR,
150 MODIFYVM_HIDKBD,
151 MODIFYVM_UARTMODE,
152 MODIFYVM_UARTTYPE,
153 MODIFYVM_UART,
154#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
155 MODIFYVM_LPTMODE,
156 MODIFYVM_LPT,
157#endif
158 MODIFYVM_GUESTMEMORYBALLOON,
159 MODIFYVM_AUDIOCONTROLLER,
160 MODIFYVM_AUDIOCODEC,
161 MODIFYVM_AUDIODRIVER,
162 MODIFYVM_AUDIOENABLED,
163 MODIFYVM_AUDIO, /* Deprecated; remove in the next major version. */
164 MODIFYVM_AUDIOIN,
165 MODIFYVM_AUDIOOUT,
166#ifdef VBOX_WITH_SHARED_CLIPBOARD
167 MODIFYVM_CLIPBOARD_MODE,
168# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
169 MODIFYVM_CLIPBOARD_FILE_TRANSFERS,
170# endif
171#endif
172 MODIFYVM_DRAGANDDROP,
173 MODIFYVM_VRDPPORT, /* VRDE: deprecated */
174 MODIFYVM_VRDPADDRESS, /* VRDE: deprecated */
175 MODIFYVM_VRDPAUTHTYPE, /* VRDE: deprecated */
176 MODIFYVM_VRDPMULTICON, /* VRDE: deprecated */
177 MODIFYVM_VRDPREUSECON, /* VRDE: deprecated */
178 MODIFYVM_VRDPVIDEOCHANNEL, /* VRDE: deprecated */
179 MODIFYVM_VRDPVIDEOCHANNELQUALITY, /* VRDE: deprecated */
180 MODIFYVM_VRDP, /* VRDE: deprecated */
181 MODIFYVM_VRDEPROPERTY,
182 MODIFYVM_VRDEPORT,
183 MODIFYVM_VRDEADDRESS,
184 MODIFYVM_VRDEAUTHTYPE,
185 MODIFYVM_VRDEAUTHLIBRARY,
186 MODIFYVM_VRDEMULTICON,
187 MODIFYVM_VRDEREUSECON,
188 MODIFYVM_VRDEVIDEOCHANNEL,
189 MODIFYVM_VRDEVIDEOCHANNELQUALITY,
190 MODIFYVM_VRDE_EXTPACK,
191 MODIFYVM_VRDE,
192 MODIFYVM_RTCUSEUTC,
193 MODIFYVM_USBRENAME,
194 MODIFYVM_USBXHCI,
195 MODIFYVM_USBEHCI,
196 MODIFYVM_USBOHCI,
197 MODIFYVM_SNAPSHOTFOLDER,
198 MODIFYVM_TELEPORTER_ENABLED,
199 MODIFYVM_TELEPORTER_PORT,
200 MODIFYVM_TELEPORTER_ADDRESS,
201 MODIFYVM_TELEPORTER_PASSWORD,
202 MODIFYVM_TELEPORTER_PASSWORD_FILE,
203 MODIFYVM_TRACING_ENABLED,
204 MODIFYVM_TRACING_CONFIG,
205 MODIFYVM_TRACING_ALLOW_VM_ACCESS,
206 MODIFYVM_HARDWARE_UUID,
207 MODIFYVM_IOCACHE,
208 MODIFYVM_IOCACHESIZE,
209 MODIFYVM_CPU_EXECTUION_CAP,
210 MODIFYVM_AUTOSTART_ENABLED,
211 MODIFYVM_AUTOSTART_DELAY,
212 MODIFYVM_AUTOSTOP_TYPE,
213#ifdef VBOX_WITH_PCI_PASSTHROUGH
214 MODIFYVM_ATTACH_PCI,
215 MODIFYVM_DETACH_PCI,
216#endif
217#ifdef VBOX_WITH_USB_CARDREADER
218 MODIFYVM_USBCARDREADER,
219#endif
220#ifdef VBOX_WITH_RECORDING
221 MODIFYVM_RECORDING,
222 MODIFYVM_RECORDING_FEATURES,
223 MODIFYVM_RECORDING_SCREENS,
224 MODIFYVM_RECORDING_FILENAME,
225 MODIFYVM_RECORDING_VIDEO_WIDTH,
226 MODIFYVM_RECORDING_VIDEO_HEIGHT,
227 MODIFYVM_RECORDING_VIDEO_RES,
228 MODIFYVM_RECORDING_VIDEO_RATE,
229 MODIFYVM_RECORDING_VIDEO_FPS,
230 MODIFYVM_RECORDING_MAXTIME,
231 MODIFYVM_RECORDING_MAXSIZE,
232 MODIFYVM_RECORDING_OPTIONS,
233#endif
234 MODIFYVM_CHIPSET,
235#if defined(VBOX_WITH_IOMMU_AMD) || defined(VBOX_WITH_IOMMU_INTEL)
236 MODIFYVM_IOMMU,
237#endif
238#if defined(VBOX_WITH_TPM)
239 MODIFYVM_TPM_LOCATION,
240 MODIFYVM_TPM_TYPE,
241#endif
242 MODIFYVM_DEFAULTFRONTEND,
243 MODIFYVM_VMPROC_PRIORITY,
244 MODIFYVM_VMEXEC_ENGINE,
245 MODIFYVM_TESTING_ENABLED,
246 MODIFYVM_TESTING_MMIO,
247 MODIFYVM_TESTING_CFG_DWORD,
248 MODIFYVM_GUEST_DEBUG_PROVIDER,
249 MODIFYVM_GUEST_DEBUG_IO_PROVIDER,
250 MODIFYVM_GUEST_DEBUG_ADDRESS,
251 MODIFYVM_GUEST_DEBUG_PORT,
252 /*
253 * x86-specific stuff.
254 */
255 MODIFYVM_X86_APIC,
256 MODIFYVM_X86_DELCPUID,
257 MODIFYVM_X86_DELCPUID_OLD, // legacy, different syntax from MODIFYVM_DELCPUID
258 MODIFYVM_X86_DELALLCPUID,
259 MODIFYVM_X86_HPET,
260 MODIFYVM_X86_HWVIRTEX,
261 MODIFYVM_X86_IBPB_ON_VM_ENTRY,
262 MODIFYVM_X86_IBPB_ON_VM_EXIT,
263 MODIFYVM_X86_L1D_FLUSH_ON_SCHED,
264 MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY,
265 MODIFYVM_X86_LARGEPAGES,
266 MODIFYVM_X86_LONGMODE,
267 MODIFYVM_X86_MDS_CLEAR_ON_SCHED,
268 MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY,
269 MODIFYVM_X86_NESTED_HW_VIRT,
270 MODIFYVM_X86_NESTEDPAGING,
271 MODIFYVM_X86_PAE,
272 MODIFYVM_X86_SETCPUID,
273 MODIFYVM_X86_SPEC_CTRL,
274 MODIFYVM_X86_TFRESET,
275 MODIFYVM_X86_VIRT_VMSAVE_VMLOAD,
276 MODIFYVM_X86_VTXUX,
277 MODIFYVM_X86_VTXVPID,
278 MODIFYVM_X86_X2APIC
279};
280
281static const RTGETOPTDEF g_aModifyVMOptions[] =
282{
283 OPT1("--name", MODIFYVM_NAME, RTGETOPT_REQ_STRING),
284 OPT1("--groups", MODIFYVM_GROUPS, RTGETOPT_REQ_STRING),
285 OPT1("--description", MODIFYVM_DESCRIPTION, RTGETOPT_REQ_STRING),
286 OPT2("--os-type", "--ostype", MODIFYVM_OSTYPE, RTGETOPT_REQ_STRING),
287 OPT2("--icon-file", "--iconfile", MODIFYVM_ICONFILE, RTGETOPT_REQ_STRING),
288 OPT1("--memory", MODIFYVM_MEMORY, RTGETOPT_REQ_UINT32),
289 OPT2("--page-fusion", "--pagefusion", MODIFYVM_PAGEFUSION, RTGETOPT_REQ_BOOL_ONOFF),
290 OPT1("--vram", MODIFYVM_VRAM, RTGETOPT_REQ_UINT32),
291 OPT1("--firmware", MODIFYVM_FIRMWARE, RTGETOPT_REQ_STRING),
292 OPT1("--acpi", MODIFYVM_ACPI, RTGETOPT_REQ_BOOL_ONOFF),
293 OPT1("--ioapic", MODIFYVM_IOAPIC, RTGETOPT_REQ_BOOL_ONOFF),
294 OPT1("--cpuid-portability-level", MODIFYVM_CPUID_PORTABILITY, RTGETOPT_REQ_UINT32),
295 OPT2("--paravirt-provider", "--paravirtprovider", MODIFYVM_PARAVIRTPROVIDER, RTGETOPT_REQ_STRING),
296 OPT2("--paravirt-debug", "--paravirtdebug", MODIFYVM_PARAVIRTDEBUG, RTGETOPT_REQ_STRING),
297 OPT1("--cpus", MODIFYVM_CPUS, RTGETOPT_REQ_UINT32),
298 OPT2("--cpu-hotplug", "--cpuhotplug", MODIFYVM_CPUHOTPLUG, RTGETOPT_REQ_BOOL_ONOFF),
299 OPT1("--cpu-profile", MODIFYVM_CPU_PROFILE, RTGETOPT_REQ_STRING),
300 OPT2("--plug-cpu", "--plugcpu", MODIFYVM_PLUGCPU, RTGETOPT_REQ_UINT32),
301 OPT2("--unplug-cpu", "--unplugcpu", MODIFYVM_UNPLUGCPU, RTGETOPT_REQ_UINT32),
302 OPT2("--cpu-execution-cap", "--cpuexecutioncap", MODIFYVM_CPU_EXECTUION_CAP, RTGETOPT_REQ_UINT32),
303 OPT2("--rtc-use-utc", "--rtcuseutc", MODIFYVM_RTCUSEUTC, RTGETOPT_REQ_BOOL_ONOFF),
304 OPT2("--graphicscontroller", "--graphicscontroller", MODIFYVM_GRAPHICSCONTROLLER, RTGETOPT_REQ_STRING),
305 OPT2("--monitor-count", "--monitorcount", MODIFYVM_MONITORCOUNT, RTGETOPT_REQ_UINT32),
306 OPT2("--accelerate-3d", "--accelerate3d", MODIFYVM_ACCELERATE3D, RTGETOPT_REQ_BOOL_ONOFF),
307#ifdef VBOX_WITH_VIDEOHWACCEL
308 OPT2("--accelerate-2d-video", "--accelerate2dvideo", MODIFYVM_ACCELERATE2DVIDEO, RTGETOPT_REQ_BOOL_ONOFF),
309#endif
310 /** Kept for backwards-compatibility. */
311 OPT1("--firmware-logo-fade-in", MODIFYVM_FWLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF),
312 /** Kept for backwards-compatibility. */
313 OPT2("--bios-logo-fade-in", "--bioslogofadein", MODIFYVM_FWLOGOFADEIN, RTGETOPT_REQ_BOOL_ONOFF),
314 OPT1("--firmware-fade-out", MODIFYVM_FWLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF),
315 /** Kept for backwards-compatibility. */
316 OPT2("--bios-logo-fade-out", "--bioslogofadeout", MODIFYVM_FWLOGOFADEOUT, RTGETOPT_REQ_BOOL_ONOFF),
317 OPT1("--firmware-logo-display-time", MODIFYVM_FWLOGODISPLAYTIME, RTGETOPT_REQ_UINT32),
318 /** Kept for backwards-compatibility. */
319 OPT2("--bios-logo-display-time", "--bioslogodisplaytime", MODIFYVM_FWLOGODISPLAYTIME, RTGETOPT_REQ_UINT32),
320 OPT1("--firmware-logo-image-path", MODIFYVM_FWLOGOIMAGEPATH, RTGETOPT_REQ_STRING),
321 /** Kept for backwards-compatibility. */
322 OPT2("--bios-logo-image-path", "--bioslogoimagepath", MODIFYVM_FWLOGOIMAGEPATH, RTGETOPT_REQ_STRING),
323 OPT1("--firmware-boot-menu", MODIFYVM_FWBOOTMENU, RTGETOPT_REQ_STRING),
324 /** Kept for backwards-compatibility. */
325 OPT2("--bios-boot-menu", "--biosbootmenu", MODIFYVM_FWBOOTMENU, RTGETOPT_REQ_STRING),
326 OPT1("--firmware-system-time-offset", MODIFYVM_FWSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64),
327 /** Kept for backwards-compatibility. */
328 OPT2("--bios-system-time-offset", "--biossystemtimeoffset", MODIFYVM_FWSYSTEMTIMEOFFSET, RTGETOPT_REQ_INT64),
329 OPT1("--firmware-apic", MODIFYVM_FWAPIC, RTGETOPT_REQ_STRING),
330 /** Kept for backwards-compatibility. */
331 OPT2("--bios-apic", "--biosapic", MODIFYVM_FWAPIC, RTGETOPT_REQ_STRING),
332 OPT1("--firmware-pxe-debug", MODIFYVM_FWPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF),
333 /** Kept for backwards-compatibility. */
334 OPT2("--bios-pxe-debug", "--biospxedebug", MODIFYVM_FWPXEDEBUG, RTGETOPT_REQ_BOOL_ONOFF),
335 OPT2("--system-uuid-le", "--system-uuid-le", MODIFYVM_SYSTEMUUIDLE, RTGETOPT_REQ_BOOL_ONOFF),
336 OPT2("--bios-auto-serial-num-gen", "--biosautoserialnumgen", MODIFYVM_FWAUTOSERIALNUMGEN, RTGETOPT_REQ_BOOL_ONOFF),
337 OPT1("--boot", MODIFYVM_BOOT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
338 OPT1("--hda", MODIFYVM_HDA, RTGETOPT_REQ_STRING), /* deprecated */
339 OPT1("--hdb", MODIFYVM_HDB, RTGETOPT_REQ_STRING), /* deprecated */
340 OPT1("--hdd", MODIFYVM_HDD, RTGETOPT_REQ_STRING), /* deprecated */
341 OPT2("--idec-ontroller", "--idecontroller", MODIFYVM_IDECONTROLLER, RTGETOPT_REQ_STRING), /* deprecated */
342 OPT2("--sata-port-count", "--sataportcount", MODIFYVM_SATAPORTCOUNT, RTGETOPT_REQ_UINT32), /* deprecated */
343 OPT2("--sata-port", "--sataport", MODIFYVM_SATAPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX), /* deprecated */
344 OPT1("--sata", MODIFYVM_SATA, RTGETOPT_REQ_STRING), /* deprecated */
345 OPT2("--scsi-port", "--scsiport", MODIFYVM_SCSIPORT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX), /* deprecated */
346 OPT2("--scsi-type", "--scsitype", MODIFYVM_SCSITYPE, RTGETOPT_REQ_STRING), /* deprecated */
347 OPT1("--scsi", MODIFYVM_SCSI, RTGETOPT_REQ_STRING), /* deprecated */
348 OPT2("--dvd-pass-through", "--dvdpassthrough", MODIFYVM_DVDPASSTHROUGH, RTGETOPT_REQ_STRING), /* deprecated */
349 OPT1("--dvd", MODIFYVM_DVD, RTGETOPT_REQ_STRING), /* deprecated */
350 OPT1("--floppy", MODIFYVM_FLOPPY, RTGETOPT_REQ_STRING), /* deprecated */
351 OPT2("--nic-trace-file", "--nictracefile", MODIFYVM_NICTRACEFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
352 OPT2("--nic-trace", "--nictrace", MODIFYVM_NICTRACE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
353 OPT2("--nic-property", "--nicproperty", MODIFYVM_NICPROPERTY, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
354 OPT2("--nic-type", "--nictype", MODIFYVM_NICTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
355 OPT2("--nic-speed", "--nicspeed", MODIFYVM_NICSPEED, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX),
356 OPT2("--nic-boot-prio", "--nicbootprio", MODIFYVM_NICBOOTPRIO, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX),
357 OPT2("--nic-promisc", "--nicpromisc", MODIFYVM_NICPROMISC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
358 OPT2("--nic-bandwidth-group", "--nicbandwidthgroup", MODIFYVM_NICBWGROUP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
359 OPT1("--nic", MODIFYVM_NIC, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
360 OPT2("--cable-connected", "--cableconnected", MODIFYVM_CABLECONNECTED, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
361 OPT2("--bridge-adapter", "--bridgeadapter", MODIFYVM_BRIDGEADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
362#ifdef VBOX_WITH_CLOUD_NET
363 OPT2("--cloud-network", "--cloudnetwork", MODIFYVM_CLOUDNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
364#endif /* VBOX_WITH_CLOUD_NET */
365 OPT2("--host-only-adapter", "--hostonlyadapter", MODIFYVM_HOSTONLYADAPTER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
366#ifdef VBOX_WITH_VMNET
367 OPT2("--host-only-net", "--hostonlynet", MODIFYVM_HOSTONLYNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
368#endif
369 OPT1("--intnet", MODIFYVM_INTNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
370 OPT2("--nic-generic-drv", "--nicgenericdrv", MODIFYVM_GENERICDRV, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
371 OPT2("--nat-network", "--natnetwork", MODIFYVM_NATNETWORKNAME, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
372 OPT2("--nat-net", "--natnet", MODIFYVM_NATNET, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
373 OPT2("--nat-bind-ip", "--natbindip", MODIFYVM_NATBINDIP, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
374 OPT2("--nat-settings", "--natsettings", MODIFYVM_NATSETTINGS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
375 OPT2("--nat-pf", "--natpf", MODIFYVM_NATPF, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
376 OPT2("--nat-alias-mode", "--nataliasmode", MODIFYVM_NATALIASMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
377 OPT2("--nat-tftp-prefix", "--nattftpprefix", MODIFYVM_NATTFTPPREFIX, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
378 OPT2("--nat-tftp-file", "--nattftpfile", MODIFYVM_NATTFTPFILE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
379 OPT2("--nat-tftp-server", "--nattftpserver", MODIFYVM_NATTFTPSERVER, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
380 OPT2("--nat-dns-pass-domain", "--natdnspassdomain", MODIFYVM_NATDNSPASSDOMAIN, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
381 OPT2("--nat-dns-proxy", "--natdnsproxy", MODIFYVM_NATDNSPROXY, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
382 OPT2("--nat-dns-host-resolver", "--natdnshostresolver", MODIFYVM_NATDNSHOSTRESOLVER, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
383 OPT2("--nat-localhostreachable", "--natlocalhostreachable", MODIFYVM_NATLOCALHOSTREACHABLE, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX),
384 OPT2("--mac-address", "--macaddress", MODIFYVM_MACADDRESS, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
385 OPT1("--mouse", MODIFYVM_HIDPTR, RTGETOPT_REQ_STRING),
386 OPT1("--keyboard", MODIFYVM_HIDKBD, RTGETOPT_REQ_STRING),
387 OPT2("--uart-mode", "--uartmode", MODIFYVM_UARTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
388 OPT2("--uart-type", "--uarttype", MODIFYVM_UARTTYPE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
389 OPT1("--uart", MODIFYVM_UART, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
390#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
391 OPT2("--lpt-mode", "--lptmode", MODIFYVM_LPTMODE, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
392 OPT1("--lpt", MODIFYVM_LPT, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX),
393#endif
394 OPT2("--guest-memory-balloon", "--guestmemoryballoon", MODIFYVM_GUESTMEMORYBALLOON, RTGETOPT_REQ_UINT32),
395 OPT2("--audio-controller", "--audiocontroller", MODIFYVM_AUDIOCONTROLLER, RTGETOPT_REQ_STRING),
396 OPT2("--audio-codec", "--audiocodec", MODIFYVM_AUDIOCODEC, RTGETOPT_REQ_STRING),
397 OPT1("--audio", MODIFYVM_AUDIO, RTGETOPT_REQ_STRING),
398 OPT2("--audio-driver", "--audiodriver", MODIFYVM_AUDIODRIVER, RTGETOPT_REQ_STRING),
399 OPT2("--audio-enabled", "--audioenabled", MODIFYVM_AUDIOENABLED, RTGETOPT_REQ_BOOL_ONOFF),
400 OPT2("--audio-in", "--audioin", MODIFYVM_AUDIOIN, RTGETOPT_REQ_BOOL_ONOFF),
401 OPT2("--audio-out", "--audioout", MODIFYVM_AUDIOOUT, RTGETOPT_REQ_BOOL_ONOFF),
402#ifdef VBOX_WITH_SHARED_CLIPBOARD
403 OPT1("--clipboard-mode", MODIFYVM_CLIPBOARD_MODE, RTGETOPT_REQ_STRING),
404 OPT1("--clipboard", MODIFYVM_CLIPBOARD_MODE, RTGETOPT_REQ_STRING), /* deprecated */
405# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
406 OPT1("--clipboard-file-transfers", MODIFYVM_CLIPBOARD_FILE_TRANSFERS, RTGETOPT_REQ_STRING),
407# endif
408#endif
409 OPT2("--drag-and-drop", "--draganddrop", MODIFYVM_DRAGANDDROP, RTGETOPT_REQ_STRING),
410 OPT2("--vrdp-port", "--vrdpport", MODIFYVM_VRDPPORT, RTGETOPT_REQ_STRING), /* deprecated */
411 OPT2("--vrdp-address", "--vrdpaddress", MODIFYVM_VRDPADDRESS, RTGETOPT_REQ_STRING), /* deprecated */
412 OPT2("--vrdp-auth-type", "--vrdpauthtype", MODIFYVM_VRDPAUTHTYPE, RTGETOPT_REQ_STRING), /* deprecated */
413 OPT2("--vrdp-multi-con", "--vrdpmulticon", MODIFYVM_VRDPMULTICON, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
414 OPT2("--vrdp-reuse-con", "--vrdpreusecon", MODIFYVM_VRDPREUSECON, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
415 OPT2("--vrdp-video-channel", "--vrdpvideochannel", MODIFYVM_VRDPVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
416 OPT2("--vrdp-video-channel-quality", "--vrdpvideochannelquality",MODIFYVM_VRDPVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING), /* deprecated */
417 OPT1("--vrdp", MODIFYVM_VRDP, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
418 OPT2("--vrde-property", "--vrdeproperty", MODIFYVM_VRDEPROPERTY, RTGETOPT_REQ_STRING),
419 OPT2("--vrde-port", "--vrdeport", MODIFYVM_VRDEPORT, RTGETOPT_REQ_STRING),
420 OPT2("--vrde-address", "--vrdeaddress", MODIFYVM_VRDEADDRESS, RTGETOPT_REQ_STRING),
421 OPT2("--vrde-auth-type", "--vrdeauthtype", MODIFYVM_VRDEAUTHTYPE, RTGETOPT_REQ_STRING),
422 OPT2("--vrde-auth-library", "--vrdeauthlibrary", MODIFYVM_VRDEAUTHLIBRARY, RTGETOPT_REQ_STRING),
423 OPT2("--vrde-multi-con", "--vrdemulticon", MODIFYVM_VRDEMULTICON, RTGETOPT_REQ_BOOL_ONOFF),
424 OPT2("--vrde-reuse-con", "--vrdereusecon", MODIFYVM_VRDEREUSECON, RTGETOPT_REQ_BOOL_ONOFF),
425 OPT2("--vrde-video-channel", "--vrdevideochannel", MODIFYVM_VRDEVIDEOCHANNEL, RTGETOPT_REQ_BOOL_ONOFF),
426 OPT2("--vrde-video-channel-quality", "--vrdevideochannelquality",MODIFYVM_VRDEVIDEOCHANNELQUALITY, RTGETOPT_REQ_STRING),
427 OPT2("--vrde-extpack", "--vrdeextpack", MODIFYVM_VRDE_EXTPACK, RTGETOPT_REQ_STRING),
428 OPT1("--vrde", MODIFYVM_VRDE, RTGETOPT_REQ_BOOL_ONOFF),
429 OPT2("--usb-rename", "--usbrename", MODIFYVM_USBRENAME, RTGETOPT_REQ_STRING),
430 OPT2("--usb-xhci", "--usbxhci", MODIFYVM_USBXHCI, RTGETOPT_REQ_BOOL_ONOFF),
431 OPT2("--usb-ehci", "--usbehci", MODIFYVM_USBEHCI, RTGETOPT_REQ_BOOL_ONOFF),
432 OPT2("--usb-ohci", "--usbohci", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF),
433 OPT1("--usb", MODIFYVM_USBOHCI, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
434 OPT2("--snapshot-folder", "--snapshotfolder", MODIFYVM_SNAPSHOTFOLDER, RTGETOPT_REQ_STRING),
435 OPT1("--teleporter", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF),
436 OPT2("--teleporter-enabled", "--teleporterenabled", MODIFYVM_TELEPORTER_ENABLED, RTGETOPT_REQ_BOOL_ONOFF), /* deprecated */
437 OPT2("--teleporter-port", "--teleporterport", MODIFYVM_TELEPORTER_PORT, RTGETOPT_REQ_UINT32),
438 OPT2("--teleporter-address", "--teleporteraddress", MODIFYVM_TELEPORTER_ADDRESS, RTGETOPT_REQ_STRING),
439 OPT2("--teleporter-password", "--teleporterpassword", MODIFYVM_TELEPORTER_PASSWORD, RTGETOPT_REQ_STRING),
440 OPT2("--teleporter-password-file", "--teleporterpasswordfile", MODIFYVM_TELEPORTER_PASSWORD_FILE, RTGETOPT_REQ_STRING),
441 OPT1("--tracing-enabled", MODIFYVM_TRACING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF),
442 OPT1("--tracing-config", MODIFYVM_TRACING_CONFIG, RTGETOPT_REQ_STRING),
443 OPT1("--tracing-allow-vm-access", MODIFYVM_TRACING_ALLOW_VM_ACCESS, RTGETOPT_REQ_BOOL_ONOFF),
444 OPT2("--hardware-uuid", "--hardwareuuid", MODIFYVM_HARDWARE_UUID, RTGETOPT_REQ_STRING),
445 OPT1("--iocache", MODIFYVM_IOCACHE, RTGETOPT_REQ_BOOL_ONOFF),
446 OPT2("--iocache-size", "--iocachesize", MODIFYVM_IOCACHESIZE, RTGETOPT_REQ_UINT32),
447 OPT1("--chipset", MODIFYVM_CHIPSET, RTGETOPT_REQ_STRING),
448#if defined(VBOX_WITH_IOMMU_AMD) || defined(VBOX_WITH_IOMMU_INTEL)
449 OPT1("--iommu", MODIFYVM_IOMMU, RTGETOPT_REQ_STRING),
450#endif
451#if defined(VBOX_WITH_TPM)
452 OPT1("--tpm-type", MODIFYVM_TPM_TYPE, RTGETOPT_REQ_STRING),
453 OPT1("--tpm-location", MODIFYVM_TPM_LOCATION, RTGETOPT_REQ_STRING),
454#endif
455#ifdef VBOX_WITH_RECORDING
456 OPT1("--recording", MODIFYVM_RECORDING, RTGETOPT_REQ_BOOL_ONOFF),
457 OPT2("--recording-screens", "--recordingscreens", MODIFYVM_RECORDING_SCREENS, RTGETOPT_REQ_STRING),
458 OPT2("--recording-file", "--recordingfile", MODIFYVM_RECORDING_FILENAME, RTGETOPT_REQ_STRING),
459 OPT2("--recording-max-time", "--recordingmaxtime", MODIFYVM_RECORDING_MAXTIME, RTGETOPT_REQ_INT32),
460 OPT2("--recording-max-size", "--recordingmaxsize", MODIFYVM_RECORDING_MAXSIZE, RTGETOPT_REQ_INT32),
461 OPT2("--recording-opts", "--recordingopts", MODIFYVM_RECORDING_OPTIONS, RTGETOPT_REQ_STRING),
462 OPT2("--recording-options", "--recordingoptions", MODIFYVM_RECORDING_OPTIONS, RTGETOPT_REQ_STRING),
463 OPT2("--recording-video-res", "--recordingvideores", MODIFYVM_RECORDING_VIDEO_RES, RTGETOPT_REQ_STRING),
464 OPT2("--recording-video-resolution", "--recordingvideoresolution",MODIFYVM_RECORDING_VIDEO_RES, RTGETOPT_REQ_STRING),
465 OPT2("--recording-video-rate", "--recordingvideorate", MODIFYVM_RECORDING_VIDEO_RATE, RTGETOPT_REQ_UINT32),
466 OPT2("--recording-video-fps", "--recordingvideofps", MODIFYVM_RECORDING_VIDEO_FPS, RTGETOPT_REQ_UINT32),
467#endif
468 OPT1("--autostart-enabled", MODIFYVM_AUTOSTART_ENABLED, RTGETOPT_REQ_BOOL_ONOFF),
469 OPT1("--autostart-delay", MODIFYVM_AUTOSTART_DELAY, RTGETOPT_REQ_UINT32),
470 OPT1("--autostop-type", MODIFYVM_AUTOSTOP_TYPE, RTGETOPT_REQ_STRING),
471#ifdef VBOX_WITH_PCI_PASSTHROUGH
472 OPT2("--pci-attach", "--pciattach", MODIFYVM_ATTACH_PCI, RTGETOPT_REQ_STRING),
473 OPT2("--pci-detach", "--pcidetach", MODIFYVM_DETACH_PCI, RTGETOPT_REQ_STRING),
474#endif
475#ifdef VBOX_WITH_USB_CARDREADER
476 OPT2("--usb-card-reader", "--usbcardreader", MODIFYVM_USBCARDREADER, RTGETOPT_REQ_BOOL_ONOFF),
477#endif
478 OPT2("--default-frontend", "--defaultfrontend", MODIFYVM_DEFAULTFRONTEND, RTGETOPT_REQ_STRING),
479 OPT1("--vm-process-priority", MODIFYVM_VMPROC_PRIORITY, RTGETOPT_REQ_STRING),
480 OPT1("--vm-execution-engine", MODIFYVM_VMEXEC_ENGINE, RTGETOPT_REQ_STRING),
481 OPT1("--testing-enabled", MODIFYVM_TESTING_ENABLED, RTGETOPT_REQ_BOOL_ONOFF),
482 OPT1("--testing-mmio", MODIFYVM_TESTING_MMIO, RTGETOPT_REQ_BOOL_ONOFF),
483 OPT1("--testing-cfg-dword", MODIFYVM_TESTING_CFG_DWORD, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX),
484 OPT1("--guest-debug-provider", MODIFYVM_GUEST_DEBUG_PROVIDER, RTGETOPT_REQ_STRING),
485 OPT1("--guest-debug-io-provider", MODIFYVM_GUEST_DEBUG_IO_PROVIDER, RTGETOPT_REQ_STRING),
486 OPT1("--guest-debug-address", MODIFYVM_GUEST_DEBUG_ADDRESS, RTGETOPT_REQ_STRING),
487 OPT1("--guest-debug-port", MODIFYVM_GUEST_DEBUG_PORT, RTGETOPT_REQ_UINT32),
488
489 /*
490 * x86-only stuff.
491 *
492 * Note: The non-prefixed options (e.g. "hpet" vs. "x86-hpet") are being kept
493 * to maintain backwards compatibility, at least for a while. Remove them before going on pension.
494 *
495 * Sorted after their MODIFYVM_X86_XXX values.
496 */
497 OPT1("--x86-apic", MODIFYVM_X86_APIC, RTGETOPT_REQ_BOOL_ONOFF),
498 OPT1("--apic", MODIFYVM_X86_APIC, RTGETOPT_REQ_BOOL_ONOFF),
499 OPT1("--x86-cpuid-remove", MODIFYVM_X86_DELCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
500 OPT1("--cpuid-remove", MODIFYVM_X86_DELCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
501 OPT1("--cpuidremove", MODIFYVM_X86_DELCPUID_OLD, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX), /* legacy - syntax differs */
502 OPT1("--x86-cpuid-remove-all", MODIFYVM_X86_DELALLCPUID, RTGETOPT_REQ_NOTHING),
503 OPT2("--cpuid-remove-all", "--cpuidremoveall", MODIFYVM_X86_DELALLCPUID, RTGETOPT_REQ_NOTHING),
504 OPT1("--x86-hpet", MODIFYVM_X86_HPET, RTGETOPT_REQ_BOOL_ONOFF),
505 OPT1("--hpet", MODIFYVM_X86_HPET, RTGETOPT_REQ_BOOL_ONOFF),
506 OPT1("--x86-hwvirtex", MODIFYVM_X86_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF),
507 OPT1("--hwvirtex", MODIFYVM_X86_HWVIRTEX, RTGETOPT_REQ_BOOL_ONOFF),
508 OPT1("--x86-ibpb-on-vm-entry", MODIFYVM_X86_IBPB_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
509 OPT1("--ibpb-on-vm-entry", MODIFYVM_X86_IBPB_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
510 OPT1("--x86-ibpb-on-vm-exit", MODIFYVM_X86_IBPB_ON_VM_EXIT, RTGETOPT_REQ_BOOL_ONOFF),
511 OPT1("--ibpb-on-vm-exit", MODIFYVM_X86_IBPB_ON_VM_EXIT, RTGETOPT_REQ_BOOL_ONOFF),
512 OPT1("--x86-l1d-flush-on-sched", MODIFYVM_X86_L1D_FLUSH_ON_SCHED, RTGETOPT_REQ_BOOL_ONOFF),
513 OPT1("--l1d-flush-on-sched", MODIFYVM_X86_L1D_FLUSH_ON_SCHED, RTGETOPT_REQ_BOOL_ONOFF),
514 OPT1("--x86-l1d-flush-on-vm-entry", MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
515 OPT1("--l1d-flush-on-vm-entry", MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
516 OPT1("--x86-large-pages", MODIFYVM_X86_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF),
517 OPT2("--large-pages", "--largepages", MODIFYVM_X86_LARGEPAGES, RTGETOPT_REQ_BOOL_ONOFF),
518 OPT1("--x86-long-mode", MODIFYVM_X86_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF),
519 OPT2("--long-mode", "--longmode", MODIFYVM_X86_LONGMODE, RTGETOPT_REQ_BOOL_ONOFF),
520 OPT1("--x86-mds-clear-on-sched", MODIFYVM_X86_MDS_CLEAR_ON_SCHED, RTGETOPT_REQ_BOOL_ONOFF),
521 OPT1("--mds-clear-on-sched", MODIFYVM_X86_MDS_CLEAR_ON_SCHED, RTGETOPT_REQ_BOOL_ONOFF),
522 OPT1("--x86-mds-clear-on-vm-entry", MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
523 OPT1("--mds-clear-on-vm-entry", MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY, RTGETOPT_REQ_BOOL_ONOFF),
524 OPT1("--x86-nested-hw-virt", MODIFYVM_X86_NESTED_HW_VIRT, RTGETOPT_REQ_BOOL_ONOFF),
525 OPT1("--nested-hw-virt", MODIFYVM_X86_NESTED_HW_VIRT, RTGETOPT_REQ_BOOL_ONOFF),
526 OPT1("--x86-nested-paging", MODIFYVM_X86_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF),
527 OPT2("--nested-paging", "--nestedpaging", MODIFYVM_X86_NESTEDPAGING, RTGETOPT_REQ_BOOL_ONOFF),
528 OPT1("--x86-pae", MODIFYVM_X86_PAE, RTGETOPT_REQ_BOOL_ONOFF),
529 OPT1("--pae", MODIFYVM_X86_PAE, RTGETOPT_REQ_BOOL_ONOFF),
530 OPT1("--x86-cpuid-set", MODIFYVM_X86_SETCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
531 OPT2("--cpuid-set", "--cpuidset", MODIFYVM_X86_SETCPUID, RTGETOPT_REQ_UINT32_OPTIONAL_PAIR | RTGETOPT_FLAG_HEX),
532 OPT1("--x86-spec-ctrl", MODIFYVM_X86_SPEC_CTRL, RTGETOPT_REQ_BOOL_ONOFF),
533 OPT1("--spec-ctrl", MODIFYVM_X86_SPEC_CTRL, RTGETOPT_REQ_BOOL_ONOFF),
534 OPT1("--x86-triple-fault-reset", MODIFYVM_X86_TFRESET, RTGETOPT_REQ_BOOL_ONOFF),
535 OPT2("--triple-fault-reset", "--triplefaultreset", MODIFYVM_X86_TFRESET, RTGETOPT_REQ_BOOL_ONOFF),
536 OPT1("--virt-vmsave-vmload", MODIFYVM_X86_VIRT_VMSAVE_VMLOAD, RTGETOPT_REQ_BOOL_ONOFF),
537 OPT1("--x86-virt-vmsave-vmload", MODIFYVM_X86_VIRT_VMSAVE_VMLOAD, RTGETOPT_REQ_BOOL_ONOFF),
538 OPT1("--x86-vtx-ux", MODIFYVM_X86_VTXUX, RTGETOPT_REQ_BOOL_ONOFF),
539 OPT2("--vtx-ux", "--vtxux", MODIFYVM_X86_VTXUX, RTGETOPT_REQ_BOOL_ONOFF),
540 OPT1("--x86-vtx-vpid", MODIFYVM_X86_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF),
541 OPT2("--vtx-vpid", "--vtxvpid", MODIFYVM_X86_VTXVPID, RTGETOPT_REQ_BOOL_ONOFF),
542 OPT1("--x86-x2apic", MODIFYVM_X86_X2APIC, RTGETOPT_REQ_BOOL_ONOFF),
543 OPT1("--x2apic", MODIFYVM_X86_X2APIC, RTGETOPT_REQ_BOOL_ONOFF),
544};
545
546static void vrdeWarningDeprecatedOption(const char *pszOption)
547{
548 RTStrmPrintf(g_pStdErr, ModifyVM::tr("Warning: '--vrdp%s' is deprecated. Use '--vrde%s'.\n"), pszOption, pszOption);
549}
550
551
552/**
553 * Wrapper around IMachine::SetExtraData that does the error reporting.
554 *
555 * @returns COM result code.
556 * @param rSessionMachine The IMachine.
557 * @param pszVariable The variable to set.
558 * @param pszValue The value to set. To delete pass empty string, not
559 * NULL.
560 */
561static HRESULT setExtraData(ComPtr<IMachine> &rSessionMachine, const char *pszVariable, const char *pszValue)
562{
563 HRESULT hrc = rSessionMachine->SetExtraData(Bstr(pszVariable).raw(), Bstr(pszValue).raw());
564 if (FAILED(hrc))
565 {
566 char *pszContext = RTStrAPrintf2("IMachine::SetExtraData('%s', '%s')", pszVariable, pszValue);
567 com::GlueHandleComError(rSessionMachine, pszContext, hrc, __FILE__, __LINE__);
568 RTStrFree(pszContext);
569 }
570 return hrc;
571}
572
573
574#ifdef VBOX_WITH_PCI_PASSTHROUGH
575/** Parse PCI address in format 01:02.03 and convert it to the numeric representation. */
576static int32_t parsePci(const char* szPciAddr)
577{
578 uint8_t aVals[3] = {0, 0, 0};
579
580 char *pszNext;
581 int vrc = RTStrToUInt8Ex(pszNext, &pszNext, 16, &aVals[0]);
582 if (RT_FAILURE(vrc) || pszNext == NULL || *pszNext != ':')
583 return -1;
584
585 vrc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[1]);
586 if (RT_FAILURE(vrc) || pszNext == NULL || *pszNext != '.')
587 return -1;
588
589 vrc = RTStrToUInt8Ex(pszNext+1, &pszNext, 16, &aVals[2]);
590 if (RT_FAILURE(vrc) || pszNext == NULL)
591 return -1;
592
593 return (aVals[0] << 8) | (aVals[1] << 3) | (aVals[2] << 0);
594}
595#endif
596
597void parseGroups(const char *pcszGroups, com::SafeArray<BSTR> *pGroups)
598{
599 while (pcszGroups)
600 {
601 char *pComma = RTStrStr(pcszGroups, ",");
602 if (pComma)
603 {
604 Bstr(pcszGroups, pComma - pcszGroups).detachTo(pGroups->appendedRaw());
605 pcszGroups = pComma + 1;
606 }
607 else
608 {
609 Bstr(pcszGroups).detachTo(pGroups->appendedRaw());
610 pcszGroups = NULL;
611 }
612 }
613}
614
615#ifdef VBOX_WITH_RECORDING
616int parseScreens(const char *pcszScreens, com::SafeArray<BOOL> *pScreens)
617{
618 if (!RTStrICmp(pcszScreens, "all"))
619 {
620 for (uint32_t i = 0; i < pScreens->size(); i++)
621 (*pScreens)[i] = TRUE;
622 return VINF_SUCCESS;
623 }
624 if (!RTStrICmp(pcszScreens, "none"))
625 {
626 for (uint32_t i = 0; i < pScreens->size(); i++)
627 (*pScreens)[i] = FALSE;
628 return VINF_SUCCESS;
629 }
630 while (pcszScreens && *pcszScreens)
631 {
632 char *pszNext;
633 uint32_t iScreen;
634 int vrc = RTStrToUInt32Ex(pcszScreens, &pszNext, 0, &iScreen);
635 if (RT_FAILURE(vrc))
636 return VERR_PARSE_ERROR;
637 if (iScreen >= pScreens->size())
638 return VERR_PARSE_ERROR;
639 if (pszNext && *pszNext)
640 {
641 pszNext = RTStrStripL(pszNext);
642 if (*pszNext != ',')
643 return VERR_PARSE_ERROR;
644 pszNext++;
645 }
646 (*pScreens)[iScreen] = true;
647 pcszScreens = pszNext;
648 }
649 return VINF_SUCCESS;
650}
651#endif
652
653static int parseNum(uint32_t uIndex, unsigned cMaxIndex, const char *pszName)
654{
655 if ( uIndex >= 1
656 && uIndex <= cMaxIndex)
657 return uIndex;
658 errorArgument(ModifyVM::tr("Invalid %s number %u"), pszName, uIndex);
659 return 0;
660}
661
662VMProcPriority_T nameToVMProcPriority(const char *pszName)
663{
664 if (!RTStrICmp(pszName, "default"))
665 return VMProcPriority_Default;
666 if (!RTStrICmp(pszName, "flat"))
667 return VMProcPriority_Flat;
668 if (!RTStrICmp(pszName, "low"))
669 return VMProcPriority_Low;
670 if (!RTStrICmp(pszName, "normal"))
671 return VMProcPriority_Normal;
672 if (!RTStrICmp(pszName, "high"))
673 return VMProcPriority_High;
674
675 return VMProcPriority_Invalid;
676}
677
678static VMExecutionEngine_T nameToVMExecEngine(const char *pszName)
679{
680 if (!RTStrICmp(pszName, "default"))
681 return VMExecutionEngine_Default;
682 if ( !RTStrICmp(pszName, "hwvirt")
683 || !RTStrICmp(pszName, "hm"))
684 return VMExecutionEngine_HwVirt;
685 if ( !RTStrICmp(pszName, "nem")
686 || !RTStrICmp(pszName, "native-api"))
687 return VMExecutionEngine_NativeApi;
688 if (!RTStrICmp(pszName, "interpreter"))
689 return VMExecutionEngine_Interpreter;
690 if ( !RTStrICmp(pszName, "recompiler"))
691 return VMExecutionEngine_Recompiler;
692
693 return VMExecutionEngine_NotSet;
694}
695
696/**
697 * Handles the x86-specific modifyvm options.
698 *
699 * @returns HRESULT
700 * @retval E_INVALIDARG if handed-in option was not being handled.
701 * @param pGetOptState Pointer to GetOpt state to use.
702 * @param c Current GetOpt value (short form).
703 * @param pValueUnion Pointer to current value union.
704 * @param sessionMachine Session machine to use.
705 * @param platformX86 x86-specific platform object to use.
706 */
707static HRESULT handleModifyVM_x86(PRTGETOPTSTATE pGetOptState, int c, PRTGETOPTUNION pValueUnion,
708 ComPtr<IMachine> &sessionMachine, ComPtr<IPlatformX86> &platformX86)
709{
710 RT_NOREF(sessionMachine);
711
712 HRESULT hrc = S_OK;
713
714 switch (c)
715 {
716 case MODIFYVM_X86_APIC:
717 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_APIC, pValueUnion->f));
718 break;
719
720 case MODIFYVM_X86_DELCPUID:
721 CHECK_ERROR(platformX86, RemoveCPUIDLeaf(pValueUnion->PairU32.uFirst, pValueUnion->PairU32.uSecond));
722 break;
723
724 case MODIFYVM_X86_DELCPUID_OLD:
725 CHECK_ERROR(platformX86, RemoveCPUIDLeaf(pValueUnion->u32, UINT32_MAX));
726 break;
727
728 case MODIFYVM_X86_DELALLCPUID:
729 CHECK_ERROR(platformX86, RemoveAllCPUIDLeaves());
730 break;
731
732 case MODIFYVM_X86_HPET:
733 CHECK_ERROR(platformX86, COMSETTER(HPETEnabled)(pValueUnion->f));
734 break;
735
736 case MODIFYVM_X86_TFRESET:
737 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_TripleFaultReset, pValueUnion->f));
738 break;
739
740 case MODIFYVM_X86_PAE:
741 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_PAE, pValueUnion->f));
742 break;
743
744 case MODIFYVM_X86_LONGMODE:
745 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_LongMode, pValueUnion->f));
746 break;
747
748 case MODIFYVM_X86_X2APIC:
749 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_X2APIC, pValueUnion->f));
750 break;
751
752 case MODIFYVM_X86_NESTEDPAGING:
753 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, pValueUnion->f));
754 break;
755
756 case MODIFYVM_X86_LARGEPAGES:
757 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_LargePages, pValueUnion->f));
758 break;
759
760 case MODIFYVM_X86_VTXVPID:
761 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_VPID, pValueUnion->f));
762 break;
763
764 case MODIFYVM_X86_VTXUX:
765 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, pValueUnion->f));
766 break;
767
768 case MODIFYVM_X86_VIRT_VMSAVE_VMLOAD:
769 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_VirtVmsaveVmload, pValueUnion->f));
770 break;
771
772 case MODIFYVM_X86_IBPB_ON_VM_EXIT:
773 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_IBPBOnVMExit, pValueUnion->f));
774 break;
775
776 case MODIFYVM_X86_IBPB_ON_VM_ENTRY:
777 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_IBPBOnVMEntry, pValueUnion->f));
778 break;
779
780 case MODIFYVM_X86_SPEC_CTRL:
781 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_SpecCtrl, pValueUnion->f));
782 break;
783
784 case MODIFYVM_X86_L1D_FLUSH_ON_SCHED:
785 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_L1DFlushOnEMTScheduling, pValueUnion->f));
786 break;
787
788 case MODIFYVM_X86_L1D_FLUSH_ON_VM_ENTRY:
789 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_L1DFlushOnVMEntry, pValueUnion->f));
790 break;
791
792 case MODIFYVM_X86_MDS_CLEAR_ON_SCHED:
793 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_MDSClearOnEMTScheduling, pValueUnion->f));
794 break;
795
796 case MODIFYVM_X86_MDS_CLEAR_ON_VM_ENTRY:
797 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_MDSClearOnVMEntry, pValueUnion->f));
798 break;
799
800 case MODIFYVM_X86_NESTED_HW_VIRT:
801 CHECK_ERROR(platformX86, SetCPUProperty(CPUPropertyTypeX86_HWVirt, pValueUnion->f));
802 break;
803
804 case MODIFYVM_X86_HWVIRTEX:
805 CHECK_ERROR(platformX86, SetHWVirtExProperty(HWVirtExPropertyType_Enabled, pValueUnion->f));
806 break;
807
808 case MODIFYVM_X86_SETCPUID:
809 {
810 uint32_t const idx = c == MODIFYVM_X86_SETCPUID ? pValueUnion->PairU32.uFirst : pValueUnion->u32;
811 uint32_t const idxSub = c == MODIFYVM_X86_SETCPUID ? pValueUnion->PairU32.uSecond : UINT32_MAX;
812 uint32_t aValue[4];
813 for (unsigned i = 0; i < 4; i++)
814 {
815 int vrc = RTGetOptFetchValue(pGetOptState, pValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
816 if (RT_FAILURE(vrc))
817 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
818 pGetOptState->pDef->pszLong);
819 aValue[i] = pValueUnion->u32;
820 }
821 CHECK_ERROR(platformX86, SetCPUIDLeaf(idx, idxSub, aValue[0], aValue[1], aValue[2], aValue[3]));
822 break;
823 }
824
825 default:
826 hrc = E_INVALIDARG;
827 break;
828 }
829
830 return hrc;
831}
832
833RTEXITCODE handleModifyVM(HandlerArg *a)
834{
835 int c;
836 HRESULT hrc;
837 Bstr name;
838
839 /* VM ID + at least one parameter. Parameter arguments are checked
840 * individually. */
841 if (a->argc < 2)
842 return errorSyntax(ModifyVM::tr("Not enough parameters"));
843
844 /* try to find the given sessionMachine */
845 ComPtr<IMachine> machine;
846 CHECK_ERROR_RET(a->virtualBox, FindMachine(Bstr(a->argv[0]).raw(),
847 machine.asOutParam()), RTEXITCODE_FAILURE);
848
849
850 /* Get the number of network adapters */
851 ULONG NetworkAdapterCount = getMaxNics(machine);
852
853 /* open a session for the VM */
854 CHECK_ERROR_RET(machine, LockMachine(a->session, LockType_Write), RTEXITCODE_FAILURE);
855
856 /* get the mutable session sessionMachine */
857 ComPtr<IMachine> sessionMachine;
858 CHECK_ERROR_RET(a->session, COMGETTER(Machine)(sessionMachine.asOutParam()), RTEXITCODE_FAILURE);
859
860 ComPtr<IFirmwareSettings> firmwareSettings;
861 CHECK_ERROR_RET(sessionMachine, COMGETTER(FirmwareSettings)(firmwareSettings.asOutParam()), RTEXITCODE_FAILURE);
862
863 ComPtr<IPlatform> platform;
864 CHECK_ERROR_RET(sessionMachine, COMGETTER(Platform)(platform.asOutParam()), RTEXITCODE_FAILURE);
865
866 /* For the x86-based options we need the x86-specific platform object. */
867 ComPtr<IPlatformX86> platformX86;
868 platform->COMGETTER(X86)(platformX86.asOutParam());
869
870 ComPtr<IGraphicsAdapter> pGraphicsAdapter;
871 sessionMachine->COMGETTER(GraphicsAdapter)(pGraphicsAdapter.asOutParam());
872
873 RTGETOPTSTATE GetOptState;
874 RTGetOptInit(&GetOptState, a->argc, a->argv, g_aModifyVMOptions,
875 RT_ELEMENTS(g_aModifyVMOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
876
877 RTGETOPTUNION ValueUnion;
878 while ( SUCCEEDED (hrc)
879 && (c = RTGetOpt(&GetOptState, &ValueUnion)))
880 {
881 switch (c)
882 {
883 case MODIFYVM_NAME:
884 {
885 CHECK_ERROR(sessionMachine, COMSETTER(Name)(Bstr(ValueUnion.psz).raw()));
886 break;
887 }
888 case MODIFYVM_GROUPS:
889 {
890 com::SafeArray<BSTR> groups;
891 parseGroups(ValueUnion.psz, &groups);
892 CHECK_ERROR(sessionMachine, COMSETTER(Groups)(ComSafeArrayAsInParam(groups)));
893 break;
894 }
895 case MODIFYVM_DESCRIPTION:
896 {
897 CHECK_ERROR(sessionMachine, COMSETTER(Description)(Bstr(ValueUnion.psz).raw()));
898 break;
899 }
900 case MODIFYVM_OSTYPE:
901 {
902 CHECK_ERROR(sessionMachine, COMSETTER(OSTypeId)(Bstr(ValueUnion.psz).raw()));
903 break;
904 }
905
906 case MODIFYVM_ICONFILE:
907 {
908 RTFILE iconFile;
909 int vrc = RTFileOpen(&iconFile, ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
910 if (RT_FAILURE(vrc))
911 {
912 RTMsgError(ModifyVM::tr("Cannot open file \"%s\": %Rrc"), ValueUnion.psz, vrc);
913 hrc = E_FAIL;
914 break;
915 }
916 uint64_t cbSize;
917 vrc = RTFileQuerySize(iconFile, &cbSize);
918 if (RT_FAILURE(vrc))
919 {
920 RTMsgError(ModifyVM::tr("Cannot get size of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
921 hrc = E_FAIL;
922 break;
923 }
924 if (cbSize > _256K)
925 {
926 RTMsgError(ModifyVM::tr("File \"%s\" is bigger than 256KByte"), ValueUnion.psz);
927 hrc = E_FAIL;
928 break;
929 }
930 SafeArray<BYTE> icon((size_t)cbSize);
931 hrc = RTFileRead(iconFile, icon.raw(), (size_t)cbSize, NULL);
932 if (RT_FAILURE(vrc))
933 {
934 RTMsgError(ModifyVM::tr("Cannot read contents of file \"%s\": %Rrc"), ValueUnion.psz, vrc);
935 hrc = E_FAIL;
936 break;
937 }
938 RTFileClose(iconFile);
939 CHECK_ERROR(sessionMachine, COMSETTER(Icon)(ComSafeArrayAsInParam(icon)));
940 break;
941 }
942
943 case MODIFYVM_MEMORY:
944 {
945 CHECK_ERROR(sessionMachine, COMSETTER(MemorySize)(ValueUnion.u32));
946 break;
947 }
948
949 case MODIFYVM_PAGEFUSION:
950 {
951 CHECK_ERROR(sessionMachine, COMSETTER(PageFusionEnabled)(ValueUnion.f));
952 break;
953 }
954
955 case MODIFYVM_VRAM:
956 {
957 CHECK_ERROR(pGraphicsAdapter, COMSETTER(VRAMSize)(ValueUnion.u32));
958 break;
959 }
960
961 case MODIFYVM_FIRMWARE:
962 {
963 if (!RTStrICmp(ValueUnion.psz, "efi"))
964 {
965 CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI));
966 }
967 else if (!RTStrICmp(ValueUnion.psz, "efi32"))
968 {
969 CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI32));
970 }
971 else if (!RTStrICmp(ValueUnion.psz, "efi64"))
972 {
973 CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFI64));
974 }
975 else if (!RTStrICmp(ValueUnion.psz, "efidual"))
976 {
977 CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_EFIDUAL));
978 }
979 else if (!RTStrICmp(ValueUnion.psz, "bios"))
980 {
981 CHECK_ERROR(firmwareSettings, COMSETTER(FirmwareType)(FirmwareType_BIOS));
982 }
983 else
984 {
985 errorArgument(ModifyVM::tr("Invalid --firmware argument '%s'"), ValueUnion.psz);
986 hrc = E_FAIL;
987 }
988 break;
989 }
990
991 case MODIFYVM_ACPI:
992 {
993 CHECK_ERROR(firmwareSettings, COMSETTER(ACPIEnabled)(ValueUnion.f));
994 break;
995 }
996
997 case MODIFYVM_IOAPIC:
998 {
999 CHECK_ERROR(firmwareSettings, COMSETTER(IOAPICEnabled)(ValueUnion.f));
1000 break;
1001 }
1002
1003 case MODIFYVM_CPUID_PORTABILITY:
1004 {
1005 CHECK_ERROR(sessionMachine, COMSETTER(CPUIDPortabilityLevel)(ValueUnion.u32));
1006 break;
1007 }
1008
1009 case MODIFYVM_PARAVIRTPROVIDER:
1010 {
1011 if ( !RTStrICmp(ValueUnion.psz, "none")
1012 || !RTStrICmp(ValueUnion.psz, "disabled"))
1013 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_None));
1014 else if (!RTStrICmp(ValueUnion.psz, "default"))
1015 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Default));
1016 else if (!RTStrICmp(ValueUnion.psz, "legacy"))
1017 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Legacy));
1018 else if (!RTStrICmp(ValueUnion.psz, "minimal"))
1019 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_Minimal));
1020 else if (!RTStrICmp(ValueUnion.psz, "hyperv"))
1021 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_HyperV));
1022 else if (!RTStrICmp(ValueUnion.psz, "kvm"))
1023 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtProvider)(ParavirtProvider_KVM));
1024 else
1025 {
1026 errorArgument(ModifyVM::tr("Invalid --paravirtprovider argument '%s'"), ValueUnion.psz);
1027 hrc = E_FAIL;
1028 }
1029 break;
1030 }
1031
1032 case MODIFYVM_PARAVIRTDEBUG:
1033 {
1034 CHECK_ERROR(sessionMachine, COMSETTER(ParavirtDebug)(Bstr(ValueUnion.psz).raw()));
1035 break;
1036 }
1037
1038 case MODIFYVM_CPUS:
1039 {
1040 CHECK_ERROR(sessionMachine, COMSETTER(CPUCount)(ValueUnion.u32));
1041 break;
1042 }
1043
1044 case MODIFYVM_RTCUSEUTC:
1045 {
1046 CHECK_ERROR(platform, COMSETTER(RTCUseUTC)(ValueUnion.f));
1047 break;
1048 }
1049
1050 case MODIFYVM_CPUHOTPLUG:
1051 {
1052 CHECK_ERROR(sessionMachine, COMSETTER(CPUHotPlugEnabled)(ValueUnion.f));
1053 break;
1054 }
1055
1056 case MODIFYVM_CPU_PROFILE:
1057 {
1058 CHECK_ERROR(sessionMachine, COMSETTER(CPUProfile)(Bstr(ValueUnion.psz).raw()));
1059 break;
1060 }
1061
1062 case MODIFYVM_PLUGCPU:
1063 {
1064 CHECK_ERROR(sessionMachine, HotPlugCPU(ValueUnion.u32));
1065 break;
1066 }
1067
1068 case MODIFYVM_UNPLUGCPU:
1069 {
1070 CHECK_ERROR(sessionMachine, HotUnplugCPU(ValueUnion.u32));
1071 break;
1072 }
1073
1074 case MODIFYVM_CPU_EXECTUION_CAP:
1075 {
1076 CHECK_ERROR(sessionMachine, COMSETTER(CPUExecutionCap)(ValueUnion.u32));
1077 break;
1078 }
1079
1080 case MODIFYVM_GRAPHICSCONTROLLER:
1081 {
1082 if ( !RTStrICmp(ValueUnion.psz, "none")
1083 || !RTStrICmp(ValueUnion.psz, "disabled"))
1084 CHECK_ERROR(pGraphicsAdapter, COMSETTER(GraphicsControllerType)(GraphicsControllerType_Null));
1085 else if ( !RTStrICmp(ValueUnion.psz, "vboxvga")
1086 || !RTStrICmp(ValueUnion.psz, "vbox")
1087 || !RTStrICmp(ValueUnion.psz, "vga")
1088 || !RTStrICmp(ValueUnion.psz, "vesa"))
1089 CHECK_ERROR(pGraphicsAdapter, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxVGA));
1090#ifdef VBOX_WITH_VMSVGA
1091 else if ( !RTStrICmp(ValueUnion.psz, "vmsvga")
1092 || !RTStrICmp(ValueUnion.psz, "vmware"))
1093 CHECK_ERROR(pGraphicsAdapter, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VMSVGA));
1094 else if ( !RTStrICmp(ValueUnion.psz, "vboxsvga")
1095 || !RTStrICmp(ValueUnion.psz, "svga"))
1096 CHECK_ERROR(pGraphicsAdapter, COMSETTER(GraphicsControllerType)(GraphicsControllerType_VBoxSVGA));
1097#endif
1098 else
1099 {
1100 errorArgument(ModifyVM::tr("Invalid --graphicscontroller argument '%s'"), ValueUnion.psz);
1101 hrc = E_FAIL;
1102 }
1103 break;
1104 }
1105
1106 case MODIFYVM_MONITORCOUNT:
1107 {
1108 CHECK_ERROR(pGraphicsAdapter, COMSETTER(MonitorCount)(ValueUnion.u32));
1109 break;
1110 }
1111
1112 case MODIFYVM_ACCELERATE3D:
1113 {
1114 CHECK_ERROR(pGraphicsAdapter, COMSETTER(Accelerate3DEnabled)(ValueUnion.f));
1115 break;
1116 }
1117
1118#ifdef VBOX_WITH_VIDEOHWACCEL
1119 case MODIFYVM_ACCELERATE2DVIDEO:
1120 {
1121 CHECK_ERROR(pGraphicsAdapter, COMSETTER(Accelerate2DVideoEnabled)(ValueUnion.f));
1122 break;
1123 }
1124#endif
1125 case MODIFYVM_FWLOGOFADEIN:
1126 {
1127 CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
1128 break;
1129 }
1130
1131 case MODIFYVM_FWLOGOFADEOUT:
1132 {
1133 CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
1134 break;
1135 }
1136
1137 case MODIFYVM_FWLOGODISPLAYTIME:
1138 {
1139 CHECK_ERROR(firmwareSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
1140 break;
1141 }
1142
1143 case MODIFYVM_FWLOGOIMAGEPATH:
1144 {
1145 CHECK_ERROR(firmwareSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
1146 break;
1147 }
1148
1149 case MODIFYVM_FWBOOTMENU:
1150 {
1151 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1152 {
1153 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_Disabled));
1154 }
1155 else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
1156 {
1157 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MenuOnly));
1158 }
1159 else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
1160 {
1161 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MessageAndMenu));
1162 }
1163 else
1164 {
1165 errorArgument(ModifyVM::tr("Invalid --biosbootmenu argument '%s'"), ValueUnion.psz);
1166 hrc = E_FAIL;
1167 }
1168 break;
1169 }
1170
1171 case MODIFYVM_FWAPIC:
1172 {
1173 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1174 {
1175 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_Disabled));
1176 }
1177 else if ( !RTStrICmp(ValueUnion.psz, "apic")
1178 || !RTStrICmp(ValueUnion.psz, "lapic")
1179 || !RTStrICmp(ValueUnion.psz, "xapic"))
1180 {
1181 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_APIC));
1182 }
1183 else if (!RTStrICmp(ValueUnion.psz, "x2apic"))
1184 {
1185 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_X2APIC));
1186 }
1187 else
1188 {
1189 errorArgument(ModifyVM::tr("Invalid --biosapic argument '%s'"), ValueUnion.psz);
1190 hrc = E_FAIL;
1191 }
1192 break;
1193 }
1194
1195 case MODIFYVM_FWSYSTEMTIMEOFFSET:
1196 {
1197 CHECK_ERROR(firmwareSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
1198 break;
1199 }
1200
1201 case MODIFYVM_FWPXEDEBUG:
1202 {
1203 CHECK_ERROR(firmwareSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
1204 break;
1205 }
1206
1207 case MODIFYVM_SYSTEMUUIDLE:
1208 {
1209 CHECK_ERROR(firmwareSettings, COMSETTER(SMBIOSUuidLittleEndian)(ValueUnion.f));
1210 break;
1211 }
1212
1213 case MODIFYVM_FWAUTOSERIALNUMGEN:
1214 {
1215 CHECK_ERROR(firmwareSettings, COMSETTER(AutoSerialNumGen)(ValueUnion.f));
1216 break;
1217 }
1218
1219 case MODIFYVM_BOOT:
1220 {
1221 if (!RTStrICmp(ValueUnion.psz, "none"))
1222 {
1223 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
1224 }
1225 else if (!RTStrICmp(ValueUnion.psz, "floppy"))
1226 {
1227 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
1228 }
1229 else if (!RTStrICmp(ValueUnion.psz, "dvd"))
1230 {
1231 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
1232 }
1233 else if (!RTStrICmp(ValueUnion.psz, "disk"))
1234 {
1235 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
1236 }
1237 else if (!RTStrICmp(ValueUnion.psz, "net"))
1238 {
1239 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
1240 }
1241 else
1242 return errorArgument(ModifyVM::tr("Invalid boot device '%s'"), ValueUnion.psz);
1243 break;
1244 }
1245
1246 case MODIFYVM_HDA: // deprecated
1247 case MODIFYVM_HDB: // deprecated
1248 case MODIFYVM_HDD: // deprecated
1249 case MODIFYVM_SATAPORT: // deprecated
1250 {
1251 uint32_t u1 = 0, u2 = 0;
1252 Bstr bstrController = L"IDE Controller";
1253
1254 switch (c)
1255 {
1256 case MODIFYVM_HDA: // deprecated
1257 u1 = 0;
1258 break;
1259
1260 case MODIFYVM_HDB: // deprecated
1261 u1 = 0;
1262 u2 = 1;
1263 break;
1264
1265 case MODIFYVM_HDD: // deprecated
1266 u1 = 1;
1267 u2 = 1;
1268 break;
1269
1270 case MODIFYVM_SATAPORT: // deprecated
1271 u1 = GetOptState.uIndex;
1272 bstrController = L"SATA";
1273 break;
1274 }
1275
1276 if (!RTStrICmp(ValueUnion.psz, "none"))
1277 {
1278 sessionMachine->DetachDevice(bstrController.raw(), u1, u2);
1279 }
1280 else
1281 {
1282 ComPtr<IMedium> hardDisk;
1283 hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1284 AccessMode_ReadWrite, hardDisk,
1285 false /* fForceNewUuidOnOpen */,
1286 false /* fSilent */);
1287 if (FAILED(hrc))
1288 break;
1289 if (hardDisk)
1290 {
1291 CHECK_ERROR(sessionMachine, AttachDevice(bstrController.raw(),
1292 u1, u2,
1293 DeviceType_HardDisk,
1294 hardDisk));
1295 }
1296 else
1297 hrc = E_FAIL;
1298 }
1299 break;
1300 }
1301
1302 case MODIFYVM_IDECONTROLLER: // deprecated
1303 {
1304 ComPtr<IStorageController> storageController;
1305 CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
1306 storageController.asOutParam()));
1307
1308 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
1309 {
1310 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
1311 }
1312 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
1313 {
1314 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
1315 }
1316 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
1317 {
1318 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
1319 }
1320 else
1321 {
1322 errorArgument(ModifyVM::tr("Invalid --idecontroller argument '%s'"), ValueUnion.psz);
1323 hrc = E_FAIL;
1324 }
1325 break;
1326 }
1327
1328 case MODIFYVM_SATAPORTCOUNT: // deprecated
1329 {
1330 ComPtr<IStorageController> SataCtl;
1331 CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("SATA").raw(),
1332 SataCtl.asOutParam()));
1333
1334 if (SUCCEEDED(hrc) && ValueUnion.u32 > 0)
1335 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
1336 break;
1337 }
1338
1339 case MODIFYVM_SATA: // deprecated
1340 {
1341 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
1342 {
1343 ComPtr<IStorageController> ctl;
1344 CHECK_ERROR(sessionMachine, AddStorageController(Bstr("SATA").raw(),
1345 StorageBus_SATA,
1346 ctl.asOutParam()));
1347 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
1348 }
1349 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1350 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw()));
1351 else
1352 return errorArgument(ModifyVM::tr("Invalid --usb argument '%s'"), ValueUnion.psz);
1353 break;
1354 }
1355
1356 case MODIFYVM_SCSIPORT: // deprecated
1357 {
1358 if (!RTStrICmp(ValueUnion.psz, "none"))
1359 {
1360 hrc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
1361 GetOptState.uIndex, 0);
1362 if (FAILED(hrc))
1363 CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(),
1364 GetOptState.uIndex, 0));
1365 }
1366 else
1367 {
1368 ComPtr<IMedium> hardDisk;
1369 hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1370 AccessMode_ReadWrite, hardDisk,
1371 false /* fForceNewUuidOnOpen */,
1372 false /* fSilent */);
1373 if (FAILED(hrc))
1374 break;
1375 if (hardDisk)
1376 {
1377 hrc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
1378 GetOptState.uIndex, 0,
1379 DeviceType_HardDisk,
1380 hardDisk);
1381 if (FAILED(hrc))
1382 CHECK_ERROR(sessionMachine,
1383 AttachDevice(Bstr("BusLogic").raw(),
1384 GetOptState.uIndex, 0,
1385 DeviceType_HardDisk,
1386 hardDisk));
1387 }
1388 else
1389 hrc = E_FAIL;
1390 }
1391 break;
1392 }
1393
1394 case MODIFYVM_SCSITYPE: // deprecated
1395 {
1396 ComPtr<IStorageController> ctl;
1397
1398 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
1399 {
1400 hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1401 if (FAILED(hrc))
1402 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1403
1404 CHECK_ERROR(sessionMachine,
1405 AddStorageController(Bstr("LsiLogic").raw(),
1406 StorageBus_SCSI,
1407 ctl.asOutParam()));
1408
1409 if (SUCCEEDED(hrc))
1410 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1411 }
1412 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
1413 {
1414 hrc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
1415 if (FAILED(hrc))
1416 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw()));
1417
1418 CHECK_ERROR(sessionMachine,
1419 AddStorageController(Bstr("BusLogic").raw(),
1420 StorageBus_SCSI,
1421 ctl.asOutParam()));
1422
1423 if (SUCCEEDED(hrc))
1424 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1425 }
1426 else
1427 return errorArgument(ModifyVM::tr("Invalid --scsitype argument '%s'"), ValueUnion.psz);
1428 break;
1429 }
1430
1431 case MODIFYVM_SCSI: // deprecated
1432 {
1433 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
1434 {
1435 ComPtr<IStorageController> ctl;
1436
1437 CHECK_ERROR(sessionMachine, AddStorageController(Bstr("BusLogic").raw(),
1438 StorageBus_SCSI,
1439 ctl.asOutParam()));
1440 if (SUCCEEDED(hrc))
1441 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1442 }
1443 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1444 {
1445 hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1446 if (FAILED(hrc))
1447 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1448 }
1449 break;
1450 }
1451
1452 case MODIFYVM_DVDPASSTHROUGH: // deprecated
1453 {
1454 CHECK_ERROR(sessionMachine, PassthroughDevice(Bstr("IDE Controller").raw(),
1455 1, 0,
1456 !RTStrICmp(ValueUnion.psz, "on")));
1457 break;
1458 }
1459
1460 case MODIFYVM_DVD: // deprecated
1461 {
1462 ComPtr<IMedium> dvdMedium;
1463
1464 /* unmount? */
1465 if (!RTStrICmp(ValueUnion.psz, "none"))
1466 {
1467 /* nothing to do, NULL object will cause unmount */
1468 }
1469 /* host drive? */
1470 else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1471 {
1472 ComPtr<IHost> host;
1473 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1474 hrc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
1475 dvdMedium.asOutParam());
1476 if (!dvdMedium)
1477 {
1478 /* 2nd try: try with the real name, important on Linux+libhal */
1479 char szPathReal[RTPATH_MAX];
1480 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
1481 {
1482 errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
1483 hrc = E_FAIL;
1484 break;
1485 }
1486 hrc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
1487 dvdMedium.asOutParam());
1488 if (!dvdMedium)
1489 {
1490 errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
1491 hrc = E_FAIL;
1492 break;
1493 }
1494 }
1495 }
1496 else
1497 {
1498 hrc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
1499 AccessMode_ReadOnly, dvdMedium,
1500 false /* fForceNewUuidOnOpen */,
1501 false /* fSilent */);
1502 if (FAILED(hrc))
1503 break;
1504 if (!dvdMedium)
1505 {
1506 hrc = E_FAIL;
1507 break;
1508 }
1509 }
1510
1511 CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller").raw(),
1512 1, 0,
1513 dvdMedium,
1514 FALSE /* aForce */));
1515 break;
1516 }
1517
1518 case MODIFYVM_FLOPPY: // deprecated
1519 {
1520 ComPtr<IMedium> floppyMedium;
1521 ComPtr<IMediumAttachment> floppyAttachment;
1522 sessionMachine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1523 0, 0, floppyAttachment.asOutParam());
1524
1525 /* disable? */
1526 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1527 {
1528 /* disable the controller */
1529 if (floppyAttachment)
1530 CHECK_ERROR(sessionMachine, DetachDevice(Bstr("Floppy Controller").raw(),
1531 0, 0));
1532 }
1533 else
1534 {
1535 /* enable the controller */
1536 if (!floppyAttachment)
1537 CHECK_ERROR(sessionMachine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1538 0, 0,
1539 DeviceType_Floppy));
1540
1541 /* unmount? */
1542 if ( !RTStrICmp(ValueUnion.psz, "none")
1543 || !RTStrICmp(ValueUnion.psz, "empty")) // deprecated
1544 {
1545 /* nothing to do, NULL object will cause unmount */
1546 }
1547 /* host drive? */
1548 else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1549 {
1550 ComPtr<IHost> host;
1551 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1552 hrc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1553 floppyMedium.asOutParam());
1554 if (!floppyMedium)
1555 {
1556 errorArgument(ModifyVM::tr("Invalid host floppy drive name \"%s\""), ValueUnion.psz + 5);
1557 hrc = E_FAIL;
1558 break;
1559 }
1560 }
1561 else
1562 {
1563 hrc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
1564 AccessMode_ReadWrite, floppyMedium,
1565 false /* fForceNewUuidOnOpen */,
1566 false /* fSilent */);
1567 if (FAILED(hrc))
1568 break;
1569 if (!floppyMedium)
1570 {
1571 hrc = E_FAIL;
1572 break;
1573 }
1574 }
1575 CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller").raw(),
1576 0, 0,
1577 floppyMedium,
1578 FALSE /* aForce */));
1579 }
1580 break;
1581 }
1582
1583 case MODIFYVM_NICTRACEFILE:
1584 {
1585
1586 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1587 break;
1588
1589 ComPtr<INetworkAdapter> nic;
1590 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1591 ASSERT(nic);
1592
1593 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1594 break;
1595 }
1596
1597 case MODIFYVM_NICTRACE:
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(TraceEnabled)(ValueUnion.f));
1607 break;
1608 }
1609
1610 case MODIFYVM_NICPROPERTY:
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 if (nic)
1620 {
1621 /* Parse 'name=value' */
1622 char *pszProperty = RTStrDup(ValueUnion.psz);
1623 if (pszProperty)
1624 {
1625 char *pDelimiter = strchr(pszProperty, '=');
1626 if (pDelimiter)
1627 {
1628 *pDelimiter = '\0';
1629
1630 Bstr bstrName = pszProperty;
1631 Bstr bstrValue = &pDelimiter[1];
1632 CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw()));
1633 }
1634 else
1635 {
1636 errorArgument(ModifyVM::tr("Invalid --nicproperty%d argument '%s'"), GetOptState.uIndex, ValueUnion.psz);
1637 hrc = E_FAIL;
1638 }
1639 RTStrFree(pszProperty);
1640 }
1641 else
1642 {
1643 RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for --nicproperty%d '%s'\n"),
1644 GetOptState.uIndex, ValueUnion.psz);
1645 hrc = E_FAIL;
1646 }
1647 }
1648 break;
1649 }
1650 case MODIFYVM_NICTYPE:
1651 {
1652 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1653 break;
1654
1655 ComPtr<INetworkAdapter> nic;
1656 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1657 ASSERT(nic);
1658
1659 if (!RTStrICmp(ValueUnion.psz, "Am79C970A"))
1660 {
1661 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1662 }
1663 else if (!RTStrICmp(ValueUnion.psz, "Am79C973"))
1664 {
1665 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1666 }
1667 else if (!RTStrICmp(ValueUnion.psz, "Am79C960"))
1668 {
1669 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C960));
1670 }
1671#ifdef VBOX_WITH_E1000
1672 else if (!RTStrICmp(ValueUnion.psz, "82540EM"))
1673 {
1674 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1675 }
1676 else if (!RTStrICmp(ValueUnion.psz, "82543GC"))
1677 {
1678 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1679 }
1680 else if (!RTStrICmp(ValueUnion.psz, "82545EM"))
1681 {
1682 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1683 }
1684#endif
1685#ifdef VBOX_WITH_VIRTIO
1686 else if (!RTStrICmp(ValueUnion.psz, "virtio"))
1687 {
1688 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1689 }
1690#endif /* VBOX_WITH_VIRTIO */
1691 else if (!RTStrICmp(ValueUnion.psz, "NE1000"))
1692 {
1693 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_NE1000));
1694 }
1695 else if (!RTStrICmp(ValueUnion.psz, "NE2000"))
1696 {
1697 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_NE2000));
1698 }
1699 else if (!RTStrICmp(ValueUnion.psz, "WD8003"))
1700 {
1701 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_WD8003));
1702 }
1703 else if (!RTStrICmp(ValueUnion.psz, "WD8013"))
1704 {
1705 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_WD8013));
1706 }
1707 else if (!RTStrICmp(ValueUnion.psz, "3C503"))
1708 {
1709 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_ELNK2));
1710 }
1711 else if (!RTStrICmp(ValueUnion.psz, "3C501"))
1712 {
1713 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_ELNK1));
1714 }
1715 else
1716 {
1717 errorArgument(ModifyVM::tr("Invalid NIC type '%s' specified for NIC %u"),
1718 ValueUnion.psz, GetOptState.uIndex);
1719 hrc = E_FAIL;
1720 }
1721 break;
1722 }
1723
1724 case MODIFYVM_NICSPEED:
1725 {
1726 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1727 break;
1728
1729 ComPtr<INetworkAdapter> nic;
1730 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1731 ASSERT(nic);
1732
1733 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1734 break;
1735 }
1736
1737 case MODIFYVM_NICBOOTPRIO:
1738 {
1739 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1740 break;
1741
1742 ComPtr<INetworkAdapter> nic;
1743 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1744 ASSERT(nic);
1745
1746 /* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1747 * to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1748 * 0 for the default lowest priority).
1749 */
1750 if (ValueUnion.u32 > 4)
1751 {
1752 errorArgument(ModifyVM::tr("Invalid boot priority '%u' specfied for NIC %u"), ValueUnion.u32, GetOptState.uIndex);
1753 hrc = E_FAIL;
1754 }
1755 else
1756 {
1757 CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1758 }
1759 break;
1760 }
1761
1762 case MODIFYVM_NICPROMISC:
1763 {
1764 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1765 if (!RTStrICmp(ValueUnion.psz, "deny"))
1766 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1767 else if ( !RTStrICmp(ValueUnion.psz, "allow-vms")
1768 || !RTStrICmp(ValueUnion.psz, "allow-network"))
1769 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1770 else if (!RTStrICmp(ValueUnion.psz, "allow-all"))
1771 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1772 else
1773 {
1774 errorArgument(ModifyVM::tr("Unknown promiscuous mode policy '%s'"), ValueUnion.psz);
1775 hrc = E_INVALIDARG;
1776 break;
1777 }
1778
1779 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1780 break;
1781
1782 ComPtr<INetworkAdapter> nic;
1783 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1784 ASSERT(nic);
1785
1786 CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1787 break;
1788 }
1789
1790 case MODIFYVM_NICBWGROUP:
1791 {
1792 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1793 break;
1794
1795 ComPtr<INetworkAdapter> nic;
1796 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1797 ASSERT(nic);
1798
1799 if (!RTStrICmp(ValueUnion.psz, "none"))
1800 {
1801 /* Just remove the bandwidth group. */
1802 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL));
1803 }
1804 else
1805 {
1806 ComPtr<IBandwidthControl> bwCtrl;
1807 ComPtr<IBandwidthGroup> bwGroup;
1808
1809 CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1810
1811 if (SUCCEEDED(hrc))
1812 {
1813 CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
1814 if (SUCCEEDED(hrc))
1815 {
1816 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
1817 }
1818 }
1819 }
1820 break;
1821 }
1822
1823 case MODIFYVM_NIC:
1824 {
1825 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1826 break;
1827
1828 ComPtr<INetworkAdapter> nic;
1829 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1830 ASSERT(nic);
1831
1832 /*
1833 * Check if the NIC is already enabled. Do not try to
1834 * enable it if it already is. That makes a
1835 * difference for saved VMs for which you can change
1836 * the NIC attachment, but can't change the NIC
1837 * enabled status (yes, the setter also should not
1838 * freak out about a no-op request).
1839 */
1840 BOOL fEnabled;;
1841 CHECK_ERROR(nic, COMGETTER(Enabled)(&fEnabled));
1842
1843 if (!RTStrICmp(ValueUnion.psz, "none"))
1844 {
1845 if (RT_BOOL(fEnabled))
1846 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1847 }
1848 else if (!RTStrICmp(ValueUnion.psz, "null"))
1849 {
1850 if (!fEnabled)
1851 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1852 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
1853 }
1854 else if (!RTStrICmp(ValueUnion.psz, "nat"))
1855 {
1856 if (!fEnabled)
1857 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1858 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
1859 }
1860 else if ( !RTStrICmp(ValueUnion.psz, "bridged")
1861 || !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1862 {
1863 if (!fEnabled)
1864 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1865 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
1866 }
1867 else if (!RTStrICmp(ValueUnion.psz, "intnet"))
1868 {
1869 if (!fEnabled)
1870 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1871 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
1872 }
1873 else if (!RTStrICmp(ValueUnion.psz, "hostonly"))
1874 {
1875 if (!fEnabled)
1876 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1877 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
1878 }
1879#ifdef VBOX_WITH_VMNET
1880 else if (!RTStrICmp(ValueUnion.psz, "hostonlynet"))
1881 {
1882 if (!fEnabled)
1883 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1884 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnlyNetwork));
1885 }
1886#endif /* VBOX_WITH_VMNET */
1887 else if (!RTStrICmp(ValueUnion.psz, "generic"))
1888 {
1889 if (!fEnabled)
1890 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1891 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
1892 }
1893 else if (!RTStrICmp(ValueUnion.psz, "natnetwork"))
1894 {
1895 if (!fEnabled)
1896 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1897 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork));
1898 }
1899#ifdef VBOX_WITH_CLOUD_NET
1900 else if (!RTStrICmp(ValueUnion.psz, "cloud"))
1901 {
1902 if (!fEnabled)
1903 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1904 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Cloud));
1905 }
1906#endif /* VBOX_WITH_CLOUD_NET */
1907 else
1908 {
1909 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
1910 hrc = E_FAIL;
1911 }
1912 break;
1913 }
1914
1915 case MODIFYVM_CABLECONNECTED:
1916 {
1917 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1918 break;
1919
1920 ComPtr<INetworkAdapter> nic;
1921 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1922 ASSERT(nic);
1923
1924 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1925 break;
1926 }
1927
1928 case MODIFYVM_BRIDGEADAPTER:
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 /* remove it? */
1938 if (!RTStrICmp(ValueUnion.psz, "none"))
1939 {
1940 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
1941 }
1942 else
1943 {
1944 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
1945 verifyHostNetworkInterfaceName(a->virtualBox, ValueUnion.psz,
1946 HostNetworkInterfaceType_Bridged);
1947 }
1948 break;
1949 }
1950
1951#ifdef VBOX_WITH_CLOUD_NET
1952 case MODIFYVM_CLOUDNET:
1953 {
1954 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1955 break;
1956
1957 ComPtr<INetworkAdapter> nic;
1958 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1959 ASSERT(nic);
1960
1961 /* remove it? */
1962 if (!RTStrICmp(ValueUnion.psz, "none"))
1963 {
1964 CHECK_ERROR(nic, COMSETTER(CloudNetwork)(Bstr().raw()));
1965 }
1966 else
1967 {
1968 CHECK_ERROR(nic, COMSETTER(CloudNetwork)(Bstr(ValueUnion.psz).raw()));
1969 }
1970 break;
1971 }
1972#endif /* VBOX_WITH_CLOUD_NET */
1973
1974 case MODIFYVM_HOSTONLYADAPTER:
1975 {
1976 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1977 break;
1978
1979 ComPtr<INetworkAdapter> nic;
1980 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1981 ASSERT(nic);
1982
1983 /* remove it? */
1984 if (!RTStrICmp(ValueUnion.psz, "none"))
1985 {
1986 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
1987 }
1988 else
1989 {
1990 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
1991 verifyHostNetworkInterfaceName(a->virtualBox, ValueUnion.psz,
1992 HostNetworkInterfaceType_HostOnly);
1993 }
1994 break;
1995 }
1996
1997#ifdef VBOX_WITH_VMNET
1998 case MODIFYVM_HOSTONLYNET:
1999 {
2000 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2001 break;
2002
2003 ComPtr<INetworkAdapter> nic;
2004 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2005 ASSERT(nic);
2006
2007 /* remove it? */
2008 if (!RTStrICmp(ValueUnion.psz, "none"))
2009 {
2010 CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr().raw()));
2011 }
2012 else
2013 {
2014 CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr(ValueUnion.psz).raw()));
2015 }
2016 break;
2017 }
2018#endif /* VBOX_WITH_VMNET */
2019
2020 case MODIFYVM_INTNET:
2021 {
2022 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2023 break;
2024
2025 ComPtr<INetworkAdapter> nic;
2026 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2027 ASSERT(nic);
2028
2029 /* remove it? */
2030 if (!RTStrICmp(ValueUnion.psz, "none"))
2031 {
2032 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
2033 }
2034 else
2035 {
2036 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
2037 }
2038 break;
2039 }
2040
2041 case MODIFYVM_GENERICDRV:
2042 {
2043 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2044 break;
2045
2046 ComPtr<INetworkAdapter> nic;
2047 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2048 ASSERT(nic);
2049
2050 CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw()));
2051 break;
2052 }
2053
2054 case MODIFYVM_NATNETWORKNAME:
2055 {
2056 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2057 break;
2058
2059 ComPtr<INetworkAdapter> nic;
2060 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2061 ASSERT(nic);
2062
2063 CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw()));
2064 break;
2065 }
2066
2067 case MODIFYVM_NATNET:
2068 {
2069 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2070 break;
2071
2072 ComPtr<INetworkAdapter> nic;
2073 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2074 ASSERT(nic);
2075
2076 ComPtr<INATEngine> engine;
2077 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2078
2079 const char *psz = ValueUnion.psz;
2080 if (!RTStrICmp("default", psz))
2081 psz = "";
2082
2083 CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
2084 break;
2085 }
2086
2087 case MODIFYVM_NATBINDIP:
2088 {
2089 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2090 break;
2091
2092 ComPtr<INetworkAdapter> nic;
2093 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2094 ASSERT(nic);
2095
2096 ComPtr<INATEngine> engine;
2097 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2098
2099 CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
2100 break;
2101 }
2102
2103#define ITERATE_TO_NEXT_TERM(ch) \
2104 do { \
2105 while (*ch != ',') \
2106 { \
2107 if (*ch == 0) \
2108 { \
2109 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"), \
2110 GetOptState.pDef->pszLong); \
2111 } \
2112 ch++; \
2113 } \
2114 *ch = '\0'; \
2115 ch++; \
2116 } while(0)
2117
2118 case MODIFYVM_NATSETTINGS:
2119 {
2120 ComPtr<INetworkAdapter> nic;
2121 ComPtr<INATEngine> engine;
2122 char *strMtu;
2123 char *strSockSnd;
2124 char *strSockRcv;
2125 char *strTcpSnd;
2126 char *strTcpRcv;
2127 char *strRaw = RTStrDup(ValueUnion.psz);
2128 char *ch = strRaw;
2129 strMtu = RTStrStrip(ch);
2130 ITERATE_TO_NEXT_TERM(ch);
2131 strSockSnd = RTStrStrip(ch);
2132 ITERATE_TO_NEXT_TERM(ch);
2133 strSockRcv = RTStrStrip(ch);
2134 ITERATE_TO_NEXT_TERM(ch);
2135 strTcpSnd = RTStrStrip(ch);
2136 ITERATE_TO_NEXT_TERM(ch);
2137 strTcpRcv = RTStrStrip(ch);
2138
2139 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2140 break;
2141
2142 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2143 ASSERT(nic);
2144
2145 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2146 CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
2147 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
2148 break;
2149 }
2150
2151
2152 case MODIFYVM_NATPF:
2153 {
2154 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2155 break;
2156
2157 ComPtr<INetworkAdapter> nic;
2158 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2159 ASSERT(nic);
2160
2161 ComPtr<INATEngine> engine;
2162 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2163
2164 /* format name:proto:hostip:hostport:guestip:guestport*/
2165 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
2166 {
2167 char *strName;
2168 char *strProto;
2169 char *strHostIp;
2170 char *strHostPort;
2171 char *strGuestIp;
2172 char *strGuestPort;
2173 char *strRaw = RTStrDup(ValueUnion.psz);
2174 char *ch = strRaw;
2175 strName = RTStrStrip(ch);
2176 ITERATE_TO_NEXT_TERM(ch);
2177 strProto = RTStrStrip(ch);
2178 ITERATE_TO_NEXT_TERM(ch);
2179 strHostIp = RTStrStrip(ch);
2180 ITERATE_TO_NEXT_TERM(ch);
2181 strHostPort = RTStrStrip(ch);
2182 ITERATE_TO_NEXT_TERM(ch);
2183 strGuestIp = RTStrStrip(ch);
2184 ITERATE_TO_NEXT_TERM(ch);
2185 strGuestPort = RTStrStrip(ch);
2186 NATProtocol_T proto;
2187 if (RTStrICmp(strProto, "udp") == 0)
2188 proto = NATProtocol_UDP;
2189 else if (RTStrICmp(strProto, "tcp") == 0)
2190 proto = NATProtocol_TCP;
2191 else
2192 {
2193 errorArgument(ModifyVM::tr("Invalid proto '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
2194 hrc = E_FAIL;
2195 break;
2196 }
2197 CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
2198 Bstr(strHostIp).raw(),
2199 RTStrToUInt16(strHostPort),
2200 Bstr(strGuestIp).raw(),
2201 RTStrToUInt16(strGuestPort)));
2202 }
2203 else
2204 {
2205 /* delete NAT Rule operation */
2206 int vrc;
2207 vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2208 if (RT_FAILURE(vrc))
2209 return errorSyntax(ModifyVM::tr("Not enough parameters"));
2210 CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
2211 }
2212 break;
2213 }
2214 #undef ITERATE_TO_NEXT_TERM
2215 case MODIFYVM_NATALIASMODE:
2216 {
2217 ComPtr<INetworkAdapter> nic;
2218 ComPtr<INATEngine> engine;
2219 uint32_t aliasMode = 0;
2220
2221 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2222 ASSERT(nic);
2223
2224 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2225 if (RTStrCmp(ValueUnion.psz, "default") == 0)
2226 aliasMode = 0;
2227 else
2228 {
2229 char *token = (char *)ValueUnion.psz;
2230 while (token)
2231 {
2232 if (RTStrNCmp(token, RT_STR_TUPLE("log")) == 0)
2233 aliasMode |= NATAliasMode_AliasLog;
2234 else if (RTStrNCmp(token, RT_STR_TUPLE("proxyonly")) == 0)
2235 aliasMode |= NATAliasMode_AliasProxyOnly;
2236 else if (RTStrNCmp(token, RT_STR_TUPLE("sameports")) == 0)
2237 aliasMode |= NATAliasMode_AliasUseSamePorts;
2238 token = RTStrStr(token, ",");
2239 if (token == NULL)
2240 break;
2241 token++;
2242 }
2243 }
2244 CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
2245 break;
2246 }
2247
2248 case MODIFYVM_NATTFTPPREFIX:
2249 {
2250 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2251 break;
2252
2253 ComPtr<INetworkAdapter> nic;
2254 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2255 ASSERT(nic);
2256
2257 ComPtr<INATEngine> engine;
2258 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2259
2260 CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
2261 break;
2262 }
2263
2264 case MODIFYVM_NATTFTPFILE:
2265 {
2266 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2267 break;
2268
2269 ComPtr<INetworkAdapter> nic;
2270 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2271 ASSERT(nic);
2272
2273 ComPtr<INATEngine> engine;
2274 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2275
2276 CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
2277 break;
2278 }
2279
2280 case MODIFYVM_NATTFTPSERVER:
2281 {
2282 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2283 break;
2284
2285 ComPtr<INetworkAdapter> nic;
2286 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2287 ASSERT(nic);
2288
2289 ComPtr<INATEngine> engine;
2290 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2291
2292 CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
2293 break;
2294 }
2295 case MODIFYVM_NATDNSPASSDOMAIN:
2296 {
2297 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2298 break;
2299
2300 ComPtr<INetworkAdapter> nic;
2301 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2302 ASSERT(nic);
2303
2304 ComPtr<INATEngine> engine;
2305 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2306
2307 CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
2308 break;
2309 }
2310
2311 case MODIFYVM_NATDNSPROXY:
2312 {
2313 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2314 break;
2315
2316 ComPtr<INetworkAdapter> nic;
2317 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2318 ASSERT(nic);
2319
2320 ComPtr<INATEngine> engine;
2321 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2322
2323 CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
2324 break;
2325 }
2326
2327 case MODIFYVM_NATDNSHOSTRESOLVER:
2328 {
2329 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2330 break;
2331
2332 ComPtr<INetworkAdapter> nic;
2333 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2334 ASSERT(nic);
2335
2336 ComPtr<INATEngine> engine;
2337 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2338
2339 CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
2340 break;
2341 }
2342
2343 case MODIFYVM_NATLOCALHOSTREACHABLE:
2344 {
2345 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2346 break;
2347
2348 ComPtr<INetworkAdapter> nic;
2349 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2350 ASSERT(nic);
2351
2352 ComPtr<INATEngine> engine;
2353 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2354
2355 CHECK_ERROR(engine, COMSETTER(LocalhostReachable)(ValueUnion.f));
2356 break;
2357 }
2358
2359 case MODIFYVM_MACADDRESS:
2360 {
2361 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2362 break;
2363
2364 ComPtr<INetworkAdapter> nic;
2365 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2366 ASSERT(nic);
2367
2368 /* generate one? */
2369 if (!RTStrICmp(ValueUnion.psz, "auto"))
2370 {
2371 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
2372 }
2373 else
2374 {
2375 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
2376 }
2377 break;
2378 }
2379
2380 case MODIFYVM_HIDPTR:
2381 {
2382 bool fEnableUsb = false;
2383 if (!RTStrICmp(ValueUnion.psz, "ps2"))
2384 {
2385 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
2386 }
2387 else if (!RTStrICmp(ValueUnion.psz, "usb"))
2388 {
2389 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
2390 if (SUCCEEDED(hrc))
2391 fEnableUsb = true;
2392 }
2393 else if (!RTStrICmp(ValueUnion.psz, "usbtablet"))
2394 {
2395 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
2396 if (SUCCEEDED(hrc))
2397 fEnableUsb = true;
2398 }
2399 else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch"))
2400 {
2401 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
2402 if (SUCCEEDED(hrc))
2403 fEnableUsb = true;
2404 }
2405 else if (!RTStrICmp(ValueUnion.psz, "usbmtscreenpluspad"))
2406 {
2407 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouchScreenPlusPad));
2408 if (SUCCEEDED(hrc))
2409 fEnableUsb = true;
2410 }
2411 else if (!RTStrICmp(ValueUnion.psz, "none"))
2412 {
2413 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_None));
2414 }
2415 else
2416 {
2417 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for pointing device"), ValueUnion.psz);
2418 hrc = E_FAIL;
2419 }
2420 if (fEnableUsb)
2421 {
2422 /* Make sure either the OHCI or xHCI controller is enabled. */
2423 ULONG cOhciCtrls = 0;
2424 ULONG cXhciCtrls = 0;
2425 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2426 if (SUCCEEDED(hrc)) {
2427 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2428 if ( SUCCEEDED(hrc)
2429 && cOhciCtrls + cXhciCtrls == 0)
2430 {
2431 /* If there's nothing, enable OHCI (always available). */
2432 ComPtr<IUSBController> UsbCtl;
2433 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2434 UsbCtl.asOutParam()));
2435 }
2436 }
2437 }
2438 break;
2439 }
2440
2441 case MODIFYVM_HIDKBD:
2442 {
2443 bool fEnableUsb = false;
2444 if (!RTStrICmp(ValueUnion.psz, "ps2"))
2445 {
2446 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
2447 }
2448 else if (!RTStrICmp(ValueUnion.psz, "usb"))
2449 {
2450 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
2451 if (SUCCEEDED(hrc))
2452 fEnableUsb = true;
2453 }
2454 else if (!RTStrICmp(ValueUnion.psz, "none"))
2455 {
2456 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_None));
2457 if (SUCCEEDED(hrc))
2458 fEnableUsb = true;
2459 }
2460 else
2461 {
2462 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for keyboard"), ValueUnion.psz);
2463 hrc = E_FAIL;
2464 }
2465 if (fEnableUsb)
2466 {
2467 /* Make sure either the OHCI or xHCI controller is enabled. */
2468 ULONG cOhciCtrls = 0;
2469 ULONG cXhciCtrls = 0;
2470 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2471 if (SUCCEEDED(hrc)) {
2472 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2473 if ( SUCCEEDED(hrc)
2474 && cOhciCtrls + cXhciCtrls == 0)
2475 {
2476 /* If there's nothing, enable OHCI (always available). */
2477 ComPtr<IUSBController> UsbCtl;
2478 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2479 UsbCtl.asOutParam()));
2480 }
2481 }
2482 }
2483 break;
2484 }
2485
2486 case MODIFYVM_UARTMODE:
2487 {
2488 ComPtr<ISerialPort> uart;
2489
2490 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2491 ASSERT(uart);
2492
2493 if (!RTStrICmp(ValueUnion.psz, "disconnected"))
2494 {
2495 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2496 }
2497 else if ( !RTStrICmp(ValueUnion.psz, "server")
2498 || !RTStrICmp(ValueUnion.psz, "client")
2499 || !RTStrICmp(ValueUnion.psz, "tcpserver")
2500 || !RTStrICmp(ValueUnion.psz, "tcpclient")
2501 || !RTStrICmp(ValueUnion.psz, "file"))
2502 {
2503 const char *pszMode = ValueUnion.psz;
2504
2505 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2506 if (RT_FAILURE(vrc))
2507 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2508 GetOptState.pDef->pszLong);
2509
2510 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2511
2512 if (!RTStrICmp(pszMode, "server"))
2513 {
2514 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2515 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2516 }
2517 else if (!RTStrICmp(pszMode, "client"))
2518 {
2519 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2520 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2521 }
2522 else if (!RTStrICmp(pszMode, "tcpserver"))
2523 {
2524 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2525 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2526 }
2527 else if (!RTStrICmp(pszMode, "tcpclient"))
2528 {
2529 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2530 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2531 }
2532 else if (!RTStrICmp(pszMode, "file"))
2533 {
2534 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
2535 }
2536 }
2537 else
2538 {
2539 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2540 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
2541 }
2542 break;
2543 }
2544
2545 case MODIFYVM_UARTTYPE:
2546 {
2547 ComPtr<ISerialPort> uart;
2548
2549 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2550 ASSERT(uart);
2551
2552 if (!RTStrICmp(ValueUnion.psz, "16450"))
2553 {
2554 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16450));
2555 }
2556 else if (!RTStrICmp(ValueUnion.psz, "16550A"))
2557 {
2558 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16550A));
2559 }
2560 else if (!RTStrICmp(ValueUnion.psz, "16750"))
2561 {
2562 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16750));
2563 }
2564 else
2565 return errorSyntax(ModifyVM::tr("Invalid argument to '%s'"),
2566 GetOptState.pDef->pszLong);
2567 break;
2568 }
2569
2570 case MODIFYVM_UART:
2571 {
2572 ComPtr<ISerialPort> uart;
2573
2574 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2575 ASSERT(uart);
2576
2577 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
2578 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
2579 else
2580 {
2581 const char *pszIOBase = ValueUnion.psz;
2582 uint32_t uVal = 0;
2583
2584 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
2585 if (RT_FAILURE(vrc))
2586 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2587 GetOptState.pDef->pszLong);
2588
2589 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
2590
2591 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2592 if (vrc != VINF_SUCCESS || uVal == 0)
2593 return errorArgument(ModifyVM::tr("Error parsing UART I/O base '%s'"), pszIOBase);
2594 CHECK_ERROR(uart, COMSETTER(IOAddress)(uVal));
2595
2596 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
2597 }
2598 break;
2599 }
2600
2601#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
2602 case MODIFYVM_LPTMODE:
2603 {
2604 ComPtr<IParallelPort> lpt;
2605
2606 CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2607 ASSERT(lpt);
2608
2609 CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2610 break;
2611 }
2612
2613 case MODIFYVM_LPT:
2614 {
2615 ComPtr<IParallelPort> lpt;
2616
2617 CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2618 ASSERT(lpt);
2619
2620 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
2621 CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE));
2622 else
2623 {
2624 const char *pszIOBase = ValueUnion.psz;
2625 uint32_t uVal = 0;
2626
2627 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT;
2628 if (RT_FAILURE(vrc))
2629 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2630 GetOptState.pDef->pszLong);
2631
2632 CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32));
2633
2634 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2635 if (vrc != VINF_SUCCESS || uVal == 0)
2636 return errorArgument(ModifyVM::tr("Error parsing LPT I/O base '%s'"), pszIOBase);
2637 CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
2638
2639 CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE));
2640 }
2641 break;
2642 }
2643#endif
2644
2645 case MODIFYVM_GUESTMEMORYBALLOON:
2646 {
2647 CHECK_ERROR(sessionMachine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
2648 break;
2649 }
2650
2651 case MODIFYVM_AUDIOCONTROLLER:
2652 {
2653 ComPtr<IAudioSettings> audioSettings;
2654 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2655 ComPtr<IAudioAdapter> audioAdapter;
2656 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2657 ASSERT(audioAdapter);
2658
2659 if (!RTStrICmp(ValueUnion.psz, "sb16"))
2660 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
2661 else if (!RTStrICmp(ValueUnion.psz, "ac97"))
2662 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
2663 else if (!RTStrICmp(ValueUnion.psz, "hda"))
2664 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
2665 else
2666 {
2667 errorArgument(ModifyVM::tr("Invalid --audiocontroller argument '%s'"), ValueUnion.psz);
2668 hrc = E_FAIL;
2669 }
2670 break;
2671 }
2672
2673 case MODIFYVM_AUDIOCODEC:
2674 {
2675 ComPtr<IAudioSettings> audioSettings;
2676 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2677 ComPtr<IAudioAdapter> audioAdapter;
2678 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2679 ASSERT(audioAdapter);
2680
2681 if (!RTStrICmp(ValueUnion.psz, "sb16"))
2682 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_SB16));
2683 else if (!RTStrICmp(ValueUnion.psz, "stac9700"))
2684 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9700));
2685 else if (!RTStrICmp(ValueUnion.psz, "ad1980"))
2686 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_AD1980));
2687 else if (!RTStrICmp(ValueUnion.psz, "stac9221"))
2688 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9221));
2689 else
2690 {
2691 errorArgument(ModifyVM::tr("Invalid --audiocodec argument '%s'"), ValueUnion.psz);
2692 hrc = E_FAIL;
2693 }
2694 break;
2695 }
2696
2697 case MODIFYVM_AUDIODRIVER:
2698 RT_FALL_THROUGH();
2699 case MODIFYVM_AUDIO: /** @todo Deprecated; remove. */
2700 {
2701 if (c == MODIFYVM_AUDIO)
2702 RTStrmPrintf(g_pStdErr,
2703 ModifyVM::tr("Warning: --audio is deprecated and will be removed soon. Use --audio-driver instead!\n"));
2704
2705 ComPtr<IAudioSettings> audioSettings;
2706 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2707 ComPtr<IAudioAdapter> audioAdapter;
2708 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2709 ASSERT(audioAdapter);
2710 /* disable? */
2711 if ( !RTStrICmp(ValueUnion.psz, "none")
2712 || !RTStrICmp(ValueUnion.psz, "null"))
2713 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
2714 else if (!RTStrICmp(ValueUnion.psz, "default"))
2715 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Default));
2716#ifdef RT_OS_WINDOWS
2717# ifdef VBOX_WITH_WINMM
2718 else if (!RTStrICmp(ValueUnion.psz, "winmm"))
2719 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WinMM));
2720# endif
2721 else if (!RTStrICmp(ValueUnion.psz, "dsound"))
2722 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
2723 else if (!RTStrICmp(ValueUnion.psz, "was"))
2724 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WAS));
2725#endif /* RT_OS_WINDOWS */
2726#ifdef VBOX_WITH_AUDIO_OSS
2727 else if (!RTStrICmp(ValueUnion.psz, "oss"))
2728 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2729#endif
2730#ifdef VBOX_WITH_AUDIO_ALSA
2731 else if (!RTStrICmp(ValueUnion.psz, "alsa"))
2732 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
2733#endif
2734#ifdef VBOX_WITH_AUDIO_PULSE
2735 else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2736 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2737#endif
2738#ifdef RT_OS_DARWIN
2739 else if (!RTStrICmp(ValueUnion.psz, "coreaudio"))
2740 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
2741#endif /* !RT_OS_DARWIN */
2742 else
2743 {
2744 errorArgument(ModifyVM::tr("Invalid %s argument '%s'"),
2745 c == MODIFYVM_AUDIO ? "--audio" : "--audio-driver", ValueUnion.psz);
2746 hrc = E_FAIL;
2747 }
2748
2749 if ( SUCCEEDED(hrc)
2750 && c == MODIFYVM_AUDIO) /* To keep the original behavior until we remove the command. */
2751 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(RTStrICmp(ValueUnion.psz, "none") == false ? false : true));
2752
2753 break;
2754 }
2755
2756 case MODIFYVM_AUDIOENABLED:
2757 {
2758 ComPtr<IAudioSettings> audioSettings;
2759 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2760 ComPtr<IAudioAdapter> audioAdapter;
2761 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2762 ASSERT(audioAdapter);
2763
2764 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(ValueUnion.f));
2765 break;
2766 }
2767
2768 case MODIFYVM_AUDIOIN:
2769 {
2770 ComPtr<IAudioSettings> audioSettings;
2771 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2772 ComPtr<IAudioAdapter> audioAdapter;
2773 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2774 ASSERT(audioAdapter);
2775
2776 CHECK_ERROR(audioAdapter, COMSETTER(EnabledIn)(ValueUnion.f));
2777 break;
2778 }
2779
2780 case MODIFYVM_AUDIOOUT:
2781 {
2782 ComPtr<IAudioSettings> audioSettings;
2783 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2784 ComPtr<IAudioAdapter> audioAdapter;
2785 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2786 ASSERT(audioAdapter);
2787
2788 CHECK_ERROR(audioAdapter, COMSETTER(EnabledOut)(ValueUnion.f));
2789 break;
2790 }
2791
2792#ifdef VBOX_WITH_SHARED_CLIPBOARD
2793 case MODIFYVM_CLIPBOARD_MODE:
2794 {
2795 ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */
2796 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2797 mode = ClipboardMode_Disabled;
2798 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2799 mode = ClipboardMode_HostToGuest;
2800 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2801 mode = ClipboardMode_GuestToHost;
2802 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2803 mode = ClipboardMode_Bidirectional;
2804 else
2805 {
2806 errorArgument(ModifyVM::tr("Invalid --clipboard-mode argument '%s'"), ValueUnion.psz);
2807 hrc = E_FAIL;
2808 }
2809 if (SUCCEEDED(hrc))
2810 {
2811 CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode));
2812 }
2813 break;
2814 }
2815
2816# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2817 case MODIFYVM_CLIPBOARD_FILE_TRANSFERS:
2818 {
2819 BOOL fEnabled = false; /* Shut up MSC */
2820 if (!RTStrICmp(ValueUnion.psz, "enabled"))
2821 fEnabled = true;
2822 else if (!RTStrICmp(ValueUnion.psz, "disabled"))
2823 fEnabled = false;
2824 else
2825 {
2826 errorArgument(ModifyVM::tr("Invalid --clipboard-file-transfers argument '%s'"), ValueUnion.psz);
2827 hrc = E_FAIL;
2828 }
2829 if (SUCCEEDED(hrc))
2830 {
2831 CHECK_ERROR(sessionMachine, COMSETTER(ClipboardFileTransfersEnabled)(fEnabled));
2832 }
2833 break;
2834 }
2835# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
2836#endif /* VBOX_WITH_SHARED_CLIPBOARD */
2837
2838 case MODIFYVM_DRAGANDDROP:
2839 {
2840 DnDMode_T mode = DnDMode_Disabled; /* Shut up MSC */
2841 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2842 mode = DnDMode_Disabled;
2843 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2844 mode = DnDMode_HostToGuest;
2845 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2846 mode = DnDMode_GuestToHost;
2847 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2848 mode = DnDMode_Bidirectional;
2849 else
2850 {
2851 errorArgument(ModifyVM::tr("Invalid --draganddrop argument '%s'"), ValueUnion.psz);
2852 hrc = E_FAIL;
2853 }
2854 if (SUCCEEDED(hrc))
2855 {
2856 CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode));
2857 }
2858 break;
2859 }
2860
2861 case MODIFYVM_VRDE_EXTPACK:
2862 {
2863 ComPtr<IVRDEServer> vrdeServer;
2864 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2865 ASSERT(vrdeServer);
2866
2867 if (vrdeServer)
2868 {
2869 if (RTStrICmp(ValueUnion.psz, "default") != 0)
2870 {
2871 Bstr bstr(ValueUnion.psz);
2872 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
2873 }
2874 else
2875 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
2876 }
2877 break;
2878 }
2879
2880 case MODIFYVM_VRDEPROPERTY:
2881 {
2882 ComPtr<IVRDEServer> vrdeServer;
2883 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2884 ASSERT(vrdeServer);
2885
2886 if (vrdeServer)
2887 {
2888 /* Parse 'name=value' */
2889 char *pszProperty = RTStrDup(ValueUnion.psz);
2890 if (pszProperty)
2891 {
2892 char *pDelimiter = strchr(pszProperty, '=');
2893 if (pDelimiter)
2894 {
2895 *pDelimiter = '\0';
2896
2897 Bstr bstrName = pszProperty;
2898 Bstr bstrValue = &pDelimiter[1];
2899 CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
2900 }
2901 else
2902 {
2903 RTStrFree(pszProperty);
2904
2905 errorArgument(ModifyVM::tr("Invalid --vrdeproperty argument '%s'"), ValueUnion.psz);
2906 hrc = E_FAIL;
2907 break;
2908 }
2909 RTStrFree(pszProperty);
2910 }
2911 else
2912 {
2913 RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for VRDE property '%s'\n"),
2914 ValueUnion.psz);
2915 hrc = E_FAIL;
2916 }
2917 }
2918 break;
2919 }
2920
2921 case MODIFYVM_VRDPPORT:
2922 vrdeWarningDeprecatedOption("port");
2923 RT_FALL_THRU();
2924
2925 case MODIFYVM_VRDEPORT:
2926 {
2927 ComPtr<IVRDEServer> vrdeServer;
2928 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2929 ASSERT(vrdeServer);
2930
2931 if (!RTStrICmp(ValueUnion.psz, "default"))
2932 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
2933 else
2934 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
2935 break;
2936 }
2937
2938 case MODIFYVM_VRDPADDRESS:
2939 vrdeWarningDeprecatedOption("address");
2940 RT_FALL_THRU();
2941
2942 case MODIFYVM_VRDEADDRESS:
2943 {
2944 ComPtr<IVRDEServer> vrdeServer;
2945 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2946 ASSERT(vrdeServer);
2947
2948 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw()));
2949 break;
2950 }
2951
2952 case MODIFYVM_VRDPAUTHTYPE:
2953 vrdeWarningDeprecatedOption("authtype");
2954 RT_FALL_THRU();
2955 case MODIFYVM_VRDEAUTHTYPE:
2956 {
2957 ComPtr<IVRDEServer> vrdeServer;
2958 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2959 ASSERT(vrdeServer);
2960
2961 if (!RTStrICmp(ValueUnion.psz, "null"))
2962 {
2963 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
2964 }
2965 else if (!RTStrICmp(ValueUnion.psz, "external"))
2966 {
2967 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
2968 }
2969 else if (!RTStrICmp(ValueUnion.psz, "guest"))
2970 {
2971 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
2972 }
2973 else
2974 {
2975 errorArgument(ModifyVM::tr("Invalid --vrdeauthtype argument '%s'"), ValueUnion.psz);
2976 hrc = E_FAIL;
2977 }
2978 break;
2979 }
2980
2981 case MODIFYVM_VRDEAUTHLIBRARY:
2982 {
2983 ComPtr<IVRDEServer> vrdeServer;
2984 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2985 ASSERT(vrdeServer);
2986
2987 if (vrdeServer)
2988 {
2989 if (RTStrICmp(ValueUnion.psz, "default") != 0)
2990 {
2991 Bstr bstr(ValueUnion.psz);
2992 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw()));
2993 }
2994 else
2995 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
2996 }
2997 break;
2998 }
2999
3000 case MODIFYVM_VRDPMULTICON:
3001 vrdeWarningDeprecatedOption("multicon");
3002 RT_FALL_THRU();
3003 case MODIFYVM_VRDEMULTICON:
3004 {
3005 ComPtr<IVRDEServer> vrdeServer;
3006 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3007 ASSERT(vrdeServer);
3008
3009 CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
3010 break;
3011 }
3012
3013 case MODIFYVM_VRDPREUSECON:
3014 vrdeWarningDeprecatedOption("reusecon");
3015 RT_FALL_THRU();
3016 case MODIFYVM_VRDEREUSECON:
3017 {
3018 ComPtr<IVRDEServer> vrdeServer;
3019 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3020 ASSERT(vrdeServer);
3021
3022 CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
3023 break;
3024 }
3025
3026 case MODIFYVM_VRDPVIDEOCHANNEL:
3027 vrdeWarningDeprecatedOption("videochannel");
3028 RT_FALL_THRU();
3029 case MODIFYVM_VRDEVIDEOCHANNEL:
3030 {
3031 ComPtr<IVRDEServer> vrdeServer;
3032 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3033 ASSERT(vrdeServer);
3034
3035 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
3036 ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
3037 break;
3038 }
3039
3040 case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
3041 vrdeWarningDeprecatedOption("videochannelquality");
3042 RT_FALL_THRU();
3043 case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
3044 {
3045 ComPtr<IVRDEServer> vrdeServer;
3046 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3047 ASSERT(vrdeServer);
3048
3049 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
3050 Bstr(ValueUnion.psz).raw()));
3051 break;
3052 }
3053
3054 case MODIFYVM_VRDP:
3055 vrdeWarningDeprecatedOption("");
3056 RT_FALL_THRU();
3057 case MODIFYVM_VRDE:
3058 {
3059 ComPtr<IVRDEServer> vrdeServer;
3060 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3061 ASSERT(vrdeServer);
3062
3063 CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
3064 break;
3065 }
3066
3067 case MODIFYVM_USBRENAME:
3068 {
3069 const char *pszName = ValueUnion.psz;
3070 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
3071 if (RT_FAILURE(vrc))
3072 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
3073 GetOptState.pDef->pszLong);
3074 const char *pszNewName = ValueUnion.psz;
3075
3076 SafeIfaceArray<IUSBController> ctrls;
3077 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3078 bool fRenamed = false;
3079 for (size_t i = 0; i < ctrls.size(); i++)
3080 {
3081 ComPtr<IUSBController> pCtrl = ctrls[i];
3082 Bstr bstrName;
3083 CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam()));
3084 if (bstrName == pszName)
3085 {
3086 bstrName = pszNewName;
3087 CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw()));
3088 fRenamed = true;
3089 }
3090 }
3091 if (!fRenamed)
3092 {
3093 errorArgument(ModifyVM::tr("Invalid --usbrename parameters, nothing renamed"));
3094 hrc = E_FAIL;
3095 }
3096 break;
3097 }
3098
3099 case MODIFYVM_USBXHCI:
3100 {
3101 ULONG cXhciCtrls = 0;
3102 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
3103 if (SUCCEEDED(hrc))
3104 {
3105 if (!cXhciCtrls && ValueUnion.f)
3106 {
3107 ComPtr<IUSBController> UsbCtl;
3108 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI,
3109 UsbCtl.asOutParam()));
3110 }
3111 else if (cXhciCtrls && !ValueUnion.f)
3112 {
3113 SafeIfaceArray<IUSBController> ctrls;
3114 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3115 for (size_t i = 0; i < ctrls.size(); i++)
3116 {
3117 ComPtr<IUSBController> pCtrl = ctrls[i];
3118 USBControllerType_T enmType;
3119 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3120 if (enmType == USBControllerType_XHCI)
3121 {
3122 Bstr ctrlName;
3123 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3124 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3125 }
3126 }
3127 }
3128 }
3129 break;
3130 }
3131
3132 case MODIFYVM_USBEHCI:
3133 {
3134 ULONG cEhciCtrls = 0;
3135 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
3136 if (SUCCEEDED(hrc))
3137 {
3138 if (!cEhciCtrls && ValueUnion.f)
3139 {
3140 ComPtr<IUSBController> UsbCtl;
3141 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
3142 UsbCtl.asOutParam()));
3143 }
3144 else if (cEhciCtrls && !ValueUnion.f)
3145 {
3146 SafeIfaceArray<IUSBController> ctrls;
3147 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3148 for (size_t i = 0; i < ctrls.size(); i++)
3149 {
3150 ComPtr<IUSBController> pCtrl = ctrls[i];
3151 USBControllerType_T enmType;
3152 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3153 if (enmType == USBControllerType_EHCI)
3154 {
3155 Bstr ctrlName;
3156 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3157 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3158 }
3159 }
3160 }
3161 }
3162 break;
3163 }
3164
3165 case MODIFYVM_USBOHCI:
3166 {
3167 ULONG cOhciCtrls = 0;
3168 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
3169 if (SUCCEEDED(hrc))
3170 {
3171 if (!cOhciCtrls && ValueUnion.f)
3172 {
3173 ComPtr<IUSBController> UsbCtl;
3174 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
3175 UsbCtl.asOutParam()));
3176 }
3177 else if (cOhciCtrls && !ValueUnion.f)
3178 {
3179 SafeIfaceArray<IUSBController> ctrls;
3180 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3181 for (size_t i = 0; i < ctrls.size(); i++)
3182 {
3183 ComPtr<IUSBController> pCtrl = ctrls[i];
3184 USBControllerType_T enmType;
3185 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3186 if (enmType == USBControllerType_OHCI)
3187 {
3188 Bstr ctrlName;
3189 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3190 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3191 }
3192 }
3193 }
3194 }
3195 break;
3196 }
3197
3198 case MODIFYVM_SNAPSHOTFOLDER:
3199 {
3200 if (!RTStrICmp(ValueUnion.psz, "default"))
3201 CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr().raw()));
3202 else
3203 CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
3204 break;
3205 }
3206
3207 case MODIFYVM_TELEPORTER_ENABLED:
3208 {
3209 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
3210 break;
3211 }
3212
3213 case MODIFYVM_TELEPORTER_PORT:
3214 {
3215 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPort)(ValueUnion.u32));
3216 break;
3217 }
3218
3219 case MODIFYVM_TELEPORTER_ADDRESS:
3220 {
3221 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
3222 break;
3223 }
3224
3225 case MODIFYVM_TELEPORTER_PASSWORD:
3226 {
3227 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
3228 break;
3229 }
3230
3231 case MODIFYVM_TELEPORTER_PASSWORD_FILE:
3232 {
3233 Utf8Str password;
3234 RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
3235 if (rcExit != RTEXITCODE_SUCCESS)
3236 hrc = E_FAIL;
3237 else
3238 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
3239 break;
3240 }
3241
3242 case MODIFYVM_TRACING_ENABLED:
3243 {
3244 CHECK_ERROR(sessionMachine, COMSETTER(TracingEnabled)(ValueUnion.f));
3245 break;
3246 }
3247
3248 case MODIFYVM_TRACING_CONFIG:
3249 {
3250 CHECK_ERROR(sessionMachine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
3251 break;
3252 }
3253
3254 case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
3255 {
3256 CHECK_ERROR(sessionMachine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
3257 break;
3258 }
3259
3260 case MODIFYVM_HARDWARE_UUID:
3261 {
3262 CHECK_ERROR(sessionMachine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
3263 break;
3264 }
3265
3266 case MODIFYVM_IOCACHE:
3267 {
3268 CHECK_ERROR(sessionMachine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
3269 break;
3270 }
3271
3272 case MODIFYVM_IOCACHESIZE:
3273 {
3274 CHECK_ERROR(sessionMachine, COMSETTER(IOCacheSize)(ValueUnion.u32));
3275 break;
3276 }
3277
3278 case MODIFYVM_CHIPSET:
3279 {
3280 if (!RTStrICmp(ValueUnion.psz, "piix3"))
3281 {
3282 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
3283 }
3284 else if (!RTStrICmp(ValueUnion.psz, "ich9"))
3285 {
3286 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_ICH9));
3287 BOOL fIoApic = FALSE;
3288 CHECK_ERROR(firmwareSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
3289 if (!fIoApic)
3290 {
3291 RTStrmPrintf(g_pStdErr, ModifyVM::tr("*** I/O APIC must be enabled for ICH9, enabling. ***\n"));
3292 CHECK_ERROR(firmwareSettings, COMSETTER(IOAPICEnabled)(TRUE));
3293 }
3294 }
3295 else if ( !RTStrICmp(ValueUnion.psz, "armv8")
3296 || !RTStrICmp(ValueUnion.psz, "armv8virtual"))
3297 {
3298 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_ARMv8Virtual));
3299 }
3300 else
3301 {
3302 errorArgument(ModifyVM::tr("Invalid --chipset argument '%s' (valid: piix3,ich9,armv8virtual)"),
3303 ValueUnion.psz);
3304 hrc = E_FAIL;
3305 }
3306 break;
3307 }
3308#if defined(VBOX_WITH_IOMMU_AMD) || defined(VBOX_WITH_IOMMU_INTEL)
3309 case MODIFYVM_IOMMU:
3310 {
3311 if ( !RTStrICmp(ValueUnion.psz, "none")
3312 || !RTStrICmp(ValueUnion.psz, "disabled"))
3313 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_None));
3314 else if (!RTStrICmp(ValueUnion.psz, "amd"))
3315 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_AMD));
3316 else if (!RTStrICmp(ValueUnion.psz, "intel"))
3317 {
3318#ifdef VBOX_WITH_IOMMU_INTEL
3319 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Intel));
3320#else
3321 errorArgument(ModifyVM::tr("Invalid --iommu argument '%s' (valid: none,amd,automatic)"), ValueUnion.psz);
3322 hrc = E_FAIL;
3323#endif
3324 }
3325 else if (!RTStrICmp(ValueUnion.psz, "automatic"))
3326 {
3327 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Automatic));
3328#ifndef VBOX_WITH_IOMMU_INTEL
3329 RTStrmPrintf(g_pStdErr,
3330 ModifyVM::tr("Warning: On Intel hosts, 'automatic' will not enable an IOMMU since the Intel IOMMU device is not supported yet.\n"));
3331#endif
3332 }
3333 else
3334 {
3335 errorArgument(ModifyVM::tr("Invalid --iommu argument '%s'"), ValueUnion.psz);
3336 hrc = E_FAIL;
3337 }
3338 break;
3339 }
3340#endif
3341#if defined(VBOX_WITH_TPM)
3342 case MODIFYVM_TPM_TYPE:
3343 {
3344 ComPtr<ITrustedPlatformModule> tpm;
3345 sessionMachine->COMGETTER(TrustedPlatformModule)(tpm.asOutParam());
3346
3347 if ( !RTStrICmp(ValueUnion.psz, "none")
3348 || !RTStrICmp(ValueUnion.psz, "disabled"))
3349 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_None));
3350 else if (!RTStrICmp(ValueUnion.psz, "1.2"))
3351 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_v1_2));
3352 else if (!RTStrICmp(ValueUnion.psz, "2.0"))
3353 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_v2_0));
3354 else if (!RTStrICmp(ValueUnion.psz, "host"))
3355 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_Host));
3356 else if (!RTStrICmp(ValueUnion.psz, "swtpm"))
3357 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_Swtpm));
3358 else
3359 {
3360 errorArgument(ModifyVM::tr("Invalid --tpm-type argument '%s'"), ValueUnion.psz);
3361 hrc = E_FAIL;
3362 }
3363 break;
3364 }
3365
3366 case MODIFYVM_TPM_LOCATION:
3367 {
3368 ComPtr<ITrustedPlatformModule> tpm;
3369 sessionMachine->COMGETTER(TrustedPlatformModule)(tpm.asOutParam());
3370
3371 CHECK_ERROR(tpm, COMSETTER(Location)(Bstr(ValueUnion.psz).raw()));
3372 break;
3373 }
3374#endif
3375#ifdef VBOX_WITH_RECORDING
3376 case MODIFYVM_RECORDING:
3377 RT_FALL_THROUGH();
3378 case MODIFYVM_RECORDING_SCREENS:
3379 RT_FALL_THROUGH();
3380 case MODIFYVM_RECORDING_FILENAME:
3381 RT_FALL_THROUGH();
3382 case MODIFYVM_RECORDING_VIDEO_WIDTH:
3383 RT_FALL_THROUGH();
3384 case MODIFYVM_RECORDING_VIDEO_HEIGHT:
3385 RT_FALL_THROUGH();
3386 case MODIFYVM_RECORDING_VIDEO_RES:
3387 RT_FALL_THROUGH();
3388 case MODIFYVM_RECORDING_VIDEO_RATE:
3389 RT_FALL_THROUGH();
3390 case MODIFYVM_RECORDING_VIDEO_FPS:
3391 RT_FALL_THROUGH();
3392 case MODIFYVM_RECORDING_MAXTIME:
3393 RT_FALL_THROUGH();
3394 case MODIFYVM_RECORDING_MAXSIZE:
3395 RT_FALL_THROUGH();
3396 case MODIFYVM_RECORDING_OPTIONS:
3397 {
3398 ComPtr<IRecordingSettings> recordingSettings;
3399 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
3400 SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
3401 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)));
3402
3403 switch (c)
3404 {
3405 case MODIFYVM_RECORDING:
3406 {
3407 CHECK_ERROR(recordingSettings, COMSETTER(Enabled)(ValueUnion.f));
3408 break;
3409 }
3410 case MODIFYVM_RECORDING_SCREENS:
3411 {
3412 ULONG cMonitors = 64;
3413 CHECK_ERROR(pGraphicsAdapter, COMGETTER(MonitorCount)(&cMonitors));
3414 com::SafeArray<BOOL> screens(cMonitors);
3415 if (RT_FAILURE(parseScreens(ValueUnion.psz, &screens)))
3416 {
3417 errorArgument(ModifyVM::tr("Invalid list of screens specified\n"));
3418 hrc = E_FAIL;
3419 break;
3420 }
3421
3422 if (cMonitors > saRecordingScreenScreens.size()) /* Paranoia. */
3423 cMonitors = (ULONG)saRecordingScreenScreens.size();
3424
3425 for (size_t i = 0; i < cMonitors; ++i)
3426 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(screens[i]));
3427 break;
3428 }
3429 case MODIFYVM_RECORDING_FILENAME:
3430 {
3431 Bstr bstr;
3432 /* empty string will fall through, leaving bstr empty */
3433 if (*ValueUnion.psz)
3434 {
3435 char szVCFileAbs[RTPATH_MAX] = "";
3436 int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs));
3437 if (RT_FAILURE(vrc))
3438 {
3439 errorArgument(ModifyVM::tr("Cannot convert filename \"%s\" to absolute path\n"), ValueUnion.psz);
3440 hrc = E_FAIL;
3441 break;
3442 }
3443 bstr = szVCFileAbs;
3444 }
3445
3446 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3447 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Filename)(bstr.raw()));
3448 break;
3449 }
3450 case MODIFYVM_RECORDING_VIDEO_WIDTH:
3451 {
3452 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3453 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
3454 break;
3455 }
3456 case MODIFYVM_RECORDING_VIDEO_HEIGHT:
3457 {
3458 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3459 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
3460 break;
3461 }
3462 case MODIFYVM_RECORDING_VIDEO_RES:
3463 {
3464 uint32_t uWidth = 0;
3465 char *pszNext;
3466 int vrc = RTStrToUInt32Ex(ValueUnion.psz, &pszNext, 0, &uWidth);
3467 if (RT_FAILURE(vrc) || vrc != VWRN_TRAILING_CHARS || !pszNext || *pszNext != 'x')
3468 {
3469 errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
3470 ValueUnion.psz);
3471 hrc = E_FAIL;
3472 break;
3473 }
3474 uint32_t uHeight = 0;
3475 vrc = RTStrToUInt32Ex(pszNext+1, NULL, 0, &uHeight);
3476 if (vrc != VINF_SUCCESS)
3477 {
3478 errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
3479 ValueUnion.psz);
3480 hrc = E_FAIL;
3481 break;
3482 }
3483
3484 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3485 {
3486 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
3487 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
3488 }
3489 break;
3490 }
3491 case MODIFYVM_RECORDING_VIDEO_RATE:
3492 {
3493 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3494 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
3495 break;
3496 }
3497 case MODIFYVM_RECORDING_VIDEO_FPS:
3498 {
3499 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3500 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
3501 break;
3502 }
3503 case MODIFYVM_RECORDING_MAXTIME:
3504 {
3505 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3506 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
3507 break;
3508 }
3509 case MODIFYVM_RECORDING_MAXSIZE:
3510 {
3511 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3512 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
3513 break;
3514 }
3515 case MODIFYVM_RECORDING_OPTIONS:
3516 {
3517 Bstr bstr(ValueUnion.psz);
3518 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3519 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Options)(bstr.raw()));
3520 break;
3521 }
3522 }
3523
3524 break;
3525 }
3526#endif
3527 case MODIFYVM_AUTOSTART_ENABLED:
3528 {
3529 CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(ValueUnion.f));
3530 break;
3531 }
3532
3533 case MODIFYVM_AUTOSTART_DELAY:
3534 {
3535 CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(ValueUnion.u32));
3536 break;
3537 }
3538
3539 case MODIFYVM_AUTOSTOP_TYPE:
3540 {
3541 AutostopType_T enmAutostopType = AutostopType_Disabled;
3542
3543 if (!RTStrICmp(ValueUnion.psz, "disabled"))
3544 enmAutostopType = AutostopType_Disabled;
3545 else if (!RTStrICmp(ValueUnion.psz, "savestate"))
3546 enmAutostopType = AutostopType_SaveState;
3547 else if (!RTStrICmp(ValueUnion.psz, "poweroff"))
3548 enmAutostopType = AutostopType_PowerOff;
3549 else if (!RTStrICmp(ValueUnion.psz, "acpishutdown"))
3550 enmAutostopType = AutostopType_AcpiShutdown;
3551 else
3552 {
3553 errorArgument(ModifyVM::tr("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)"),
3554 ValueUnion.psz);
3555 hrc = E_FAIL;
3556 }
3557
3558 if (SUCCEEDED(hrc))
3559 CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType));
3560 break;
3561 }
3562#ifdef VBOX_WITH_PCI_PASSTHROUGH
3563 case MODIFYVM_ATTACH_PCI:
3564 {
3565 const char* pAt = strchr(ValueUnion.psz, '@');
3566 int32_t iHostAddr, iGuestAddr;
3567
3568 iHostAddr = parsePci(ValueUnion.psz);
3569 iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
3570
3571 if (iHostAddr == -1 || iGuestAddr == -1)
3572 {
3573 errorArgument(ModifyVM::tr("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')"),
3574 ValueUnion.psz);
3575 hrc = E_FAIL;
3576 }
3577 else
3578 {
3579 CHECK_ERROR(sessionMachine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
3580 }
3581
3582 break;
3583 }
3584 case MODIFYVM_DETACH_PCI:
3585 {
3586 int32_t iHostAddr;
3587
3588 iHostAddr = parsePci(ValueUnion.psz);
3589 if (iHostAddr == -1)
3590 {
3591 errorArgument(ModifyVM::tr("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')"), ValueUnion.psz);
3592 hrc = E_FAIL;
3593 }
3594 else
3595 {
3596 CHECK_ERROR(sessionMachine, DetachHostPCIDevice(iHostAddr));
3597 }
3598
3599 break;
3600 }
3601#endif
3602
3603#ifdef VBOX_WITH_USB_CARDREADER
3604 case MODIFYVM_USBCARDREADER:
3605 {
3606 CHECK_ERROR(sessionMachine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f));
3607 break;
3608 }
3609#endif /* VBOX_WITH_USB_CARDREADER */
3610
3611 case MODIFYVM_DEFAULTFRONTEND:
3612 {
3613 Bstr bstr(ValueUnion.psz);
3614 if (bstr == "default")
3615 bstr = Bstr::Empty;
3616 CHECK_ERROR(sessionMachine, COMSETTER(DefaultFrontend)(bstr.raw()));
3617 break;
3618 }
3619
3620 case MODIFYVM_VMPROC_PRIORITY:
3621 {
3622 VMProcPriority_T enmPriority = nameToVMProcPriority(ValueUnion.psz);
3623 if (enmPriority == VMProcPriority_Invalid)
3624 {
3625 errorArgument(ModifyVM::tr("Invalid --vm-process-priority '%s'"), ValueUnion.psz);
3626 hrc = E_FAIL;
3627 }
3628 else
3629 {
3630 CHECK_ERROR(sessionMachine, COMSETTER(VMProcessPriority)(enmPriority));
3631 }
3632 break;
3633 }
3634
3635 case MODIFYVM_VMEXEC_ENGINE:
3636 {
3637 VMExecutionEngine_T enmExecEngine = nameToVMExecEngine(ValueUnion.psz);
3638 if (enmExecEngine == VMExecutionEngine_NotSet)
3639 {
3640 errorArgument(ModifyVM::tr("Invalid --vm-execution-engine '%s'"), ValueUnion.psz);
3641 hrc = E_FAIL;
3642 }
3643 else
3644 {
3645 CHECK_ERROR(sessionMachine, COMSETTER(VMExecutionEngine)(enmExecEngine));
3646 }
3647 break;
3648 }
3649
3650 case MODIFYVM_TESTING_ENABLED:
3651 hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", ValueUnion.f ? "1" : "");
3652 break;
3653
3654 case MODIFYVM_TESTING_MMIO:
3655 hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO", ValueUnion.f ? "1" : "");
3656 break;
3657
3658 case MODIFYVM_TESTING_CFG_DWORD:
3659 if (GetOptState.uIndex <= 9)
3660 {
3661 char szVar[128];
3662 RTStrPrintf(szVar, sizeof(szVar), "VBoxInternal/Devices/VMMDev/0/Config/TestingCfgDword%u",
3663 GetOptState.uIndex);
3664 char szValue[32];
3665 RTStrPrintf(szValue, sizeof(szValue), "%u", ValueUnion.u32);
3666 hrc = setExtraData(sessionMachine, szVar, szValue);
3667 }
3668 else
3669 hrc = errorArgumentHr(ModifyVM::tr("--testing-cfg-dword index %u is out of range: 0 thru 9"),
3670 GetOptState.uIndex);
3671 break;
3672
3673 case MODIFYVM_GUEST_DEBUG_PROVIDER:
3674 {
3675 ComPtr<IGuestDebugControl> gstDbgCtrl;
3676 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3677
3678 GuestDebugProvider_T enmDebugProvider = GuestDebugProvider_None;
3679
3680 if (!RTStrICmp(ValueUnion.psz, "none"))
3681 enmDebugProvider = GuestDebugProvider_None;
3682 else if (!RTStrICmp(ValueUnion.psz, "native"))
3683 enmDebugProvider = GuestDebugProvider_Native;
3684 else if (!RTStrICmp(ValueUnion.psz, "gdb"))
3685 enmDebugProvider = GuestDebugProvider_GDB;
3686 else if (!RTStrICmp(ValueUnion.psz, "kd"))
3687 enmDebugProvider = GuestDebugProvider_KD;
3688 else
3689 {
3690 errorArgument(ModifyVM::tr("Invalid --guest-debug-provider '%s' (valid: none, native, gdb, kd)"),
3691 ValueUnion.psz);
3692 hrc = E_FAIL;
3693 }
3694
3695 if (SUCCEEDED(hrc))
3696 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugProvider)(enmDebugProvider));
3697 break;
3698 }
3699
3700 case MODIFYVM_GUEST_DEBUG_IO_PROVIDER:
3701 {
3702 ComPtr<IGuestDebugControl> gstDbgCtrl;
3703 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3704
3705 GuestDebugIoProvider_T enmDebugIoProvider = GuestDebugIoProvider_None;
3706
3707 if (!RTStrICmp(ValueUnion.psz, "none"))
3708 enmDebugIoProvider = GuestDebugIoProvider_None;
3709 else if (!RTStrICmp(ValueUnion.psz, "tcp"))
3710 enmDebugIoProvider = GuestDebugIoProvider_TCP;
3711 else if (!RTStrICmp(ValueUnion.psz, "udp"))
3712 enmDebugIoProvider = GuestDebugIoProvider_UDP;
3713 else if (!RTStrICmp(ValueUnion.psz, "ipc"))
3714 enmDebugIoProvider = GuestDebugIoProvider_IPC;
3715 else
3716 {
3717 errorArgument(ModifyVM::tr("Invalid --guest-debug-io-provider '%s' (valid: none, tcp, udp, ipc)"),
3718 ValueUnion.psz);
3719 hrc = E_FAIL;
3720 }
3721
3722 if (SUCCEEDED(hrc))
3723 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugIoProvider)(enmDebugIoProvider));
3724 break;
3725 }
3726
3727 case MODIFYVM_GUEST_DEBUG_ADDRESS:
3728 {
3729 ComPtr<IGuestDebugControl> gstDbgCtrl;
3730 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3731
3732 Bstr bstr(ValueUnion.psz);
3733 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugAddress)(bstr.raw()));
3734 break;
3735 }
3736
3737 case MODIFYVM_GUEST_DEBUG_PORT:
3738 {
3739 ComPtr<IGuestDebugControl> gstDbgCtrl;
3740 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3741 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugPort)(ValueUnion.u32));
3742 break;
3743 }
3744
3745 default:
3746 {
3747 hrc = handleModifyVM_x86(&GetOptState, c, &ValueUnion, sessionMachine, platformX86);
3748 if (FAILED(hrc))
3749 errorGetOpt(c, &ValueUnion);
3750 break;
3751 }
3752 }
3753 }
3754
3755 /* commit changes */
3756 if (SUCCEEDED(hrc))
3757 CHECK_ERROR(sessionMachine, SaveSettings());
3758
3759 /* it's important to always close sessions */
3760 a->session->UnlockMachine();
3761
3762 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3763}
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use