VirtualBox

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

Last change on this file was 108973, checked in by vboxsync, 5 weeks ago

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