VirtualBox

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

Last change on this file since 108938 was 108641, checked in by vboxsync, 7 weeks ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette