VirtualBox

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

Last change on this file since 107745 was 107548, checked in by vboxsync, 6 weeks ago

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

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