VirtualBox

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

最後變更 在這個檔案從108371是 108003,由 vboxsync 提交於 7 週 前

Parfait: fixed the warning "Change of signedness on implicit conversion" in VBoxManage part of the code
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 172.6 KB
行 
1/* $Id: VBoxManageModifyVM.cpp 108003 2025-01-31 14:05:57Z 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.alldomusa.eu.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_NATFORWARD_BROADCAST,
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 OPT1("--nat-forward-broadcast", MODIFYVM_NATFORWARD_BROADCAST, 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, (size_t)(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 (int)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 vrc = 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 if ( !RTStrICmp(ValueUnion.psz, "qemuramfb")
1128 || !RTStrICmp(ValueUnion.psz, "qemu-ramfb"))
1129 CHECK_ERROR(pGraphicsAdapter, COMSETTER(GraphicsControllerType)(GraphicsControllerType_QemuRamFB));
1130 else
1131 {
1132 errorArgument(ModifyVM::tr("Invalid --graphicscontroller argument '%s'"), ValueUnion.psz);
1133 hrc = E_FAIL;
1134 }
1135 break;
1136 }
1137
1138 case MODIFYVM_MONITORCOUNT:
1139 {
1140 CHECK_ERROR(pGraphicsAdapter, COMSETTER(MonitorCount)(ValueUnion.u32));
1141 break;
1142 }
1143
1144 case MODIFYVM_ACCELERATE3D:
1145 {
1146 CHECK_ERROR(pGraphicsAdapter, SetFeature(GraphicsFeature_Acceleration3D, ValueUnion.f));
1147 break;
1148 }
1149
1150#ifdef VBOX_WITH_VIDEOHWACCEL
1151 case MODIFYVM_ACCELERATE2DVIDEO:
1152 {
1153 CHECK_ERROR(pGraphicsAdapter, SetFeature(GraphicsFeature_Acceleration2DVideo, ValueUnion.f));
1154 break;
1155 }
1156#endif
1157 case MODIFYVM_FWLOGOFADEIN:
1158 {
1159 CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeIn)(ValueUnion.f));
1160 break;
1161 }
1162
1163 case MODIFYVM_FWLOGOFADEOUT:
1164 {
1165 CHECK_ERROR(firmwareSettings, COMSETTER(LogoFadeOut)(ValueUnion.f));
1166 break;
1167 }
1168
1169 case MODIFYVM_FWLOGODISPLAYTIME:
1170 {
1171 CHECK_ERROR(firmwareSettings, COMSETTER(LogoDisplayTime)(ValueUnion.u32));
1172 break;
1173 }
1174
1175 case MODIFYVM_FWLOGOIMAGEPATH:
1176 {
1177 CHECK_ERROR(firmwareSettings, COMSETTER(LogoImagePath)(Bstr(ValueUnion.psz).raw()));
1178 break;
1179 }
1180
1181 case MODIFYVM_FWBOOTMENU:
1182 {
1183 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1184 {
1185 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_Disabled));
1186 }
1187 else if (!RTStrICmp(ValueUnion.psz, "menuonly"))
1188 {
1189 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MenuOnly));
1190 }
1191 else if (!RTStrICmp(ValueUnion.psz, "messageandmenu"))
1192 {
1193 CHECK_ERROR(firmwareSettings, COMSETTER(BootMenuMode)(FirmwareBootMenuMode_MessageAndMenu));
1194 }
1195 else
1196 {
1197 errorArgument(ModifyVM::tr("Invalid --biosbootmenu argument '%s'"), ValueUnion.psz);
1198 hrc = E_FAIL;
1199 }
1200 break;
1201 }
1202
1203 case MODIFYVM_FWAPIC:
1204 {
1205 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1206 {
1207 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_Disabled));
1208 }
1209 else if ( !RTStrICmp(ValueUnion.psz, "apic")
1210 || !RTStrICmp(ValueUnion.psz, "lapic")
1211 || !RTStrICmp(ValueUnion.psz, "xapic"))
1212 {
1213 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_APIC));
1214 }
1215 else if (!RTStrICmp(ValueUnion.psz, "x2apic"))
1216 {
1217 CHECK_ERROR(firmwareSettings, COMSETTER(APICMode)(APICMode_X2APIC));
1218 }
1219 else
1220 {
1221 errorArgument(ModifyVM::tr("Invalid --biosapic argument '%s'"), ValueUnion.psz);
1222 hrc = E_FAIL;
1223 }
1224 break;
1225 }
1226
1227 case MODIFYVM_FWSYSTEMTIMEOFFSET:
1228 {
1229 CHECK_ERROR(firmwareSettings, COMSETTER(TimeOffset)(ValueUnion.i64));
1230 break;
1231 }
1232
1233 case MODIFYVM_FWPXEDEBUG:
1234 {
1235 CHECK_ERROR(firmwareSettings, COMSETTER(PXEDebugEnabled)(ValueUnion.f));
1236 break;
1237 }
1238
1239 case MODIFYVM_SYSTEMUUIDLE:
1240 {
1241 CHECK_ERROR(firmwareSettings, COMSETTER(SMBIOSUuidLittleEndian)(ValueUnion.f));
1242 break;
1243 }
1244
1245 case MODIFYVM_FWAUTOSERIALNUMGEN:
1246 {
1247 CHECK_ERROR(firmwareSettings, COMSETTER(AutoSerialNumGen)(ValueUnion.f));
1248 break;
1249 }
1250
1251 case MODIFYVM_BOOT:
1252 {
1253 if (!RTStrICmp(ValueUnion.psz, "none"))
1254 {
1255 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Null));
1256 }
1257 else if (!RTStrICmp(ValueUnion.psz, "floppy"))
1258 {
1259 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Floppy));
1260 }
1261 else if (!RTStrICmp(ValueUnion.psz, "dvd"))
1262 {
1263 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_DVD));
1264 }
1265 else if (!RTStrICmp(ValueUnion.psz, "disk"))
1266 {
1267 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_HardDisk));
1268 }
1269 else if (!RTStrICmp(ValueUnion.psz, "net"))
1270 {
1271 CHECK_ERROR(sessionMachine, SetBootOrder(GetOptState.uIndex, DeviceType_Network));
1272 }
1273 else
1274 return errorArgument(ModifyVM::tr("Invalid boot device '%s'"), ValueUnion.psz);
1275 break;
1276 }
1277
1278 case MODIFYVM_HDA: // deprecated
1279 case MODIFYVM_HDB: // deprecated
1280 case MODIFYVM_HDD: // deprecated
1281 case MODIFYVM_SATAPORT: // deprecated
1282 {
1283 uint32_t u1 = 0, u2 = 0;
1284 Bstr bstrController = L"IDE Controller";
1285
1286 switch (c)
1287 {
1288 case MODIFYVM_HDA: // deprecated
1289 u1 = 0;
1290 break;
1291
1292 case MODIFYVM_HDB: // deprecated
1293 u1 = 0;
1294 u2 = 1;
1295 break;
1296
1297 case MODIFYVM_HDD: // deprecated
1298 u1 = 1;
1299 u2 = 1;
1300 break;
1301
1302 case MODIFYVM_SATAPORT: // deprecated
1303 u1 = GetOptState.uIndex;
1304 bstrController = L"SATA";
1305 break;
1306 }
1307
1308 if (!RTStrICmp(ValueUnion.psz, "none"))
1309 {
1310 sessionMachine->DetachDevice(bstrController.raw(), (LONG)u1, (LONG)u2);
1311 }
1312 else
1313 {
1314 ComPtr<IMedium> hardDisk;
1315 hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1316 AccessMode_ReadWrite, hardDisk,
1317 false /* fForceNewUuidOnOpen */,
1318 false /* fSilent */);
1319 if (FAILED(hrc))
1320 break;
1321 if (hardDisk)
1322 {
1323 CHECK_ERROR(sessionMachine, AttachDevice(bstrController.raw(),
1324 (LONG)u1, (LONG)u2,
1325 DeviceType_HardDisk,
1326 hardDisk));
1327 }
1328 else
1329 hrc = E_FAIL;
1330 }
1331 break;
1332 }
1333
1334 case MODIFYVM_IDECONTROLLER: // deprecated
1335 {
1336 ComPtr<IStorageController> storageController;
1337 CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("IDE Controller").raw(),
1338 storageController.asOutParam()));
1339
1340 if (!RTStrICmp(ValueUnion.psz, "PIIX3"))
1341 {
1342 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX3));
1343 }
1344 else if (!RTStrICmp(ValueUnion.psz, "PIIX4"))
1345 {
1346 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_PIIX4));
1347 }
1348 else if (!RTStrICmp(ValueUnion.psz, "ICH6"))
1349 {
1350 CHECK_ERROR(storageController, COMSETTER(ControllerType)(StorageControllerType_ICH6));
1351 }
1352 else
1353 {
1354 errorArgument(ModifyVM::tr("Invalid --idecontroller argument '%s'"), ValueUnion.psz);
1355 hrc = E_FAIL;
1356 }
1357 break;
1358 }
1359
1360 case MODIFYVM_SATAPORTCOUNT: // deprecated
1361 {
1362 ComPtr<IStorageController> SataCtl;
1363 CHECK_ERROR(sessionMachine, GetStorageControllerByName(Bstr("SATA").raw(),
1364 SataCtl.asOutParam()));
1365
1366 if (SUCCEEDED(hrc) && ValueUnion.u32 > 0)
1367 CHECK_ERROR(SataCtl, COMSETTER(PortCount)(ValueUnion.u32));
1368 break;
1369 }
1370
1371 case MODIFYVM_SATA: // deprecated
1372 {
1373 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
1374 {
1375 ComPtr<IStorageController> ctl;
1376 CHECK_ERROR(sessionMachine, AddStorageController(Bstr("SATA").raw(),
1377 StorageBus_SATA,
1378 ctl.asOutParam()));
1379 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_IntelAhci));
1380 }
1381 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1382 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("SATA").raw()));
1383 else
1384 return errorArgument(ModifyVM::tr("Invalid --usb argument '%s'"), ValueUnion.psz);
1385 break;
1386 }
1387
1388 case MODIFYVM_SCSIPORT: // deprecated
1389 {
1390 if (!RTStrICmp(ValueUnion.psz, "none"))
1391 {
1392 hrc = sessionMachine->DetachDevice(Bstr("LsiLogic").raw(),
1393 (LONG)GetOptState.uIndex, 0);
1394 if (FAILED(hrc))
1395 CHECK_ERROR(sessionMachine, DetachDevice(Bstr("BusLogic").raw(),
1396 (LONG)GetOptState.uIndex, 0));
1397 }
1398 else
1399 {
1400 ComPtr<IMedium> hardDisk;
1401 hrc = openMedium(a, ValueUnion.psz, DeviceType_HardDisk,
1402 AccessMode_ReadWrite, hardDisk,
1403 false /* fForceNewUuidOnOpen */,
1404 false /* fSilent */);
1405 if (FAILED(hrc))
1406 break;
1407 if (hardDisk)
1408 {
1409 hrc = sessionMachine->AttachDevice(Bstr("LsiLogic").raw(),
1410 (LONG)GetOptState.uIndex, 0,
1411 DeviceType_HardDisk,
1412 hardDisk);
1413 if (FAILED(hrc))
1414 CHECK_ERROR(sessionMachine,
1415 AttachDevice(Bstr("BusLogic").raw(),
1416 (LONG)GetOptState.uIndex, 0,
1417 DeviceType_HardDisk,
1418 hardDisk));
1419 }
1420 else
1421 hrc = E_FAIL;
1422 }
1423 break;
1424 }
1425
1426 case MODIFYVM_SCSITYPE: // deprecated
1427 {
1428 ComPtr<IStorageController> ctl;
1429
1430 if (!RTStrICmp(ValueUnion.psz, "LsiLogic"))
1431 {
1432 hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1433 if (FAILED(hrc))
1434 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1435
1436 CHECK_ERROR(sessionMachine,
1437 AddStorageController(Bstr("LsiLogic").raw(),
1438 StorageBus_SCSI,
1439 ctl.asOutParam()));
1440
1441 if (SUCCEEDED(hrc))
1442 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_LsiLogic));
1443 }
1444 else if (!RTStrICmp(ValueUnion.psz, "BusLogic"))
1445 {
1446 hrc = sessionMachine->RemoveStorageController(Bstr("LsiLogic").raw());
1447 if (FAILED(hrc))
1448 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("BusLogic").raw()));
1449
1450 CHECK_ERROR(sessionMachine,
1451 AddStorageController(Bstr("BusLogic").raw(),
1452 StorageBus_SCSI,
1453 ctl.asOutParam()));
1454
1455 if (SUCCEEDED(hrc))
1456 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1457 }
1458 else
1459 return errorArgument(ModifyVM::tr("Invalid --scsitype argument '%s'"), ValueUnion.psz);
1460 break;
1461 }
1462
1463 case MODIFYVM_SCSI: // deprecated
1464 {
1465 if (!RTStrICmp(ValueUnion.psz, "on") || !RTStrICmp(ValueUnion.psz, "enable"))
1466 {
1467 ComPtr<IStorageController> ctl;
1468
1469 CHECK_ERROR(sessionMachine, AddStorageController(Bstr("BusLogic").raw(),
1470 StorageBus_SCSI,
1471 ctl.asOutParam()));
1472 if (SUCCEEDED(hrc))
1473 CHECK_ERROR(ctl, COMSETTER(ControllerType)(StorageControllerType_BusLogic));
1474 }
1475 else if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
1476 {
1477 hrc = sessionMachine->RemoveStorageController(Bstr("BusLogic").raw());
1478 if (FAILED(hrc))
1479 CHECK_ERROR(sessionMachine, RemoveStorageController(Bstr("LsiLogic").raw()));
1480 }
1481 break;
1482 }
1483
1484 case MODIFYVM_DVDPASSTHROUGH: // deprecated
1485 {
1486 CHECK_ERROR(sessionMachine, PassthroughDevice(Bstr("IDE Controller").raw(),
1487 1, 0,
1488 !RTStrICmp(ValueUnion.psz, "on")));
1489 break;
1490 }
1491
1492 case MODIFYVM_DVD: // deprecated
1493 {
1494 ComPtr<IMedium> dvdMedium;
1495
1496 /* unmount? */
1497 if (!RTStrICmp(ValueUnion.psz, "none"))
1498 {
1499 /* nothing to do, NULL object will cause unmount */
1500 }
1501 /* host drive? */
1502 else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1503 {
1504 ComPtr<IHost> host;
1505 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1506 hrc = host->FindHostDVDDrive(Bstr(ValueUnion.psz + 5).raw(),
1507 dvdMedium.asOutParam());
1508 if (!dvdMedium)
1509 {
1510 /* 2nd try: try with the real name, important on Linux+libhal */
1511 char szPathReal[RTPATH_MAX];
1512 if (RT_FAILURE(RTPathReal(ValueUnion.psz + 5, szPathReal, sizeof(szPathReal))))
1513 {
1514 errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
1515 hrc = E_FAIL;
1516 break;
1517 }
1518 hrc = host->FindHostDVDDrive(Bstr(szPathReal).raw(),
1519 dvdMedium.asOutParam());
1520 if (!dvdMedium)
1521 {
1522 errorArgument(ModifyVM::tr("Invalid host DVD drive name \"%s\""), ValueUnion.psz + 5);
1523 hrc = E_FAIL;
1524 break;
1525 }
1526 }
1527 }
1528 else
1529 {
1530 hrc = openMedium(a, ValueUnion.psz, DeviceType_DVD,
1531 AccessMode_ReadOnly, dvdMedium,
1532 false /* fForceNewUuidOnOpen */,
1533 false /* fSilent */);
1534 if (FAILED(hrc))
1535 break;
1536 if (!dvdMedium)
1537 {
1538 hrc = E_FAIL;
1539 break;
1540 }
1541 }
1542
1543 CHECK_ERROR(sessionMachine, MountMedium(Bstr("IDE Controller").raw(),
1544 1, 0,
1545 dvdMedium,
1546 FALSE /* aForce */));
1547 break;
1548 }
1549
1550 case MODIFYVM_FLOPPY: // deprecated
1551 {
1552 ComPtr<IMedium> floppyMedium;
1553 ComPtr<IMediumAttachment> floppyAttachment;
1554 sessionMachine->GetMediumAttachment(Bstr("Floppy Controller").raw(),
1555 0, 0, floppyAttachment.asOutParam());
1556
1557 /* disable? */
1558 if (!RTStrICmp(ValueUnion.psz, "disabled"))
1559 {
1560 /* disable the controller */
1561 if (floppyAttachment)
1562 CHECK_ERROR(sessionMachine, DetachDevice(Bstr("Floppy Controller").raw(),
1563 0, 0));
1564 }
1565 else
1566 {
1567 /* enable the controller */
1568 if (!floppyAttachment)
1569 CHECK_ERROR(sessionMachine, AttachDeviceWithoutMedium(Bstr("Floppy Controller").raw(),
1570 0, 0,
1571 DeviceType_Floppy));
1572
1573 /* unmount? */
1574 if ( !RTStrICmp(ValueUnion.psz, "none")
1575 || !RTStrICmp(ValueUnion.psz, "empty")) // deprecated
1576 {
1577 /* nothing to do, NULL object will cause unmount */
1578 }
1579 /* host drive? */
1580 else if (!RTStrNICmp(ValueUnion.psz, RT_STR_TUPLE("host:")))
1581 {
1582 ComPtr<IHost> host;
1583 CHECK_ERROR(a->virtualBox, COMGETTER(Host)(host.asOutParam()));
1584 hrc = host->FindHostFloppyDrive(Bstr(ValueUnion.psz + 5).raw(),
1585 floppyMedium.asOutParam());
1586 if (!floppyMedium)
1587 {
1588 errorArgument(ModifyVM::tr("Invalid host floppy drive name \"%s\""), ValueUnion.psz + 5);
1589 hrc = E_FAIL;
1590 break;
1591 }
1592 }
1593 else
1594 {
1595 hrc = openMedium(a, ValueUnion.psz, DeviceType_Floppy,
1596 AccessMode_ReadWrite, floppyMedium,
1597 false /* fForceNewUuidOnOpen */,
1598 false /* fSilent */);
1599 if (FAILED(hrc))
1600 break;
1601 if (!floppyMedium)
1602 {
1603 hrc = E_FAIL;
1604 break;
1605 }
1606 }
1607 CHECK_ERROR(sessionMachine, MountMedium(Bstr("Floppy Controller").raw(),
1608 0, 0,
1609 floppyMedium,
1610 FALSE /* aForce */));
1611 }
1612 break;
1613 }
1614
1615 case MODIFYVM_NICTRACEFILE:
1616 {
1617
1618 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1619 break;
1620
1621 ComPtr<INetworkAdapter> nic;
1622 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1623 ASSERT(nic);
1624
1625 CHECK_ERROR(nic, COMSETTER(TraceFile)(Bstr(ValueUnion.psz).raw()));
1626 break;
1627 }
1628
1629 case MODIFYVM_NICTRACE:
1630 {
1631 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1632 break;
1633
1634 ComPtr<INetworkAdapter> nic;
1635 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1636 ASSERT(nic);
1637
1638 CHECK_ERROR(nic, COMSETTER(TraceEnabled)(ValueUnion.f));
1639 break;
1640 }
1641
1642 case MODIFYVM_NICPROPERTY:
1643 {
1644 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1645 break;
1646
1647 ComPtr<INetworkAdapter> nic;
1648 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1649 ASSERT(nic);
1650
1651 if (nic)
1652 {
1653 /* Parse 'name=value' */
1654 char *pszProperty = RTStrDup(ValueUnion.psz);
1655 if (pszProperty)
1656 {
1657 char *pDelimiter = strchr(pszProperty, '=');
1658 if (pDelimiter)
1659 {
1660 *pDelimiter = '\0';
1661
1662 Bstr bstrName = pszProperty;
1663 Bstr bstrValue = &pDelimiter[1];
1664 CHECK_ERROR(nic, SetProperty(bstrName.raw(), bstrValue.raw()));
1665 }
1666 else
1667 {
1668 errorArgument(ModifyVM::tr("Invalid --nicproperty%d argument '%s'"), GetOptState.uIndex, ValueUnion.psz);
1669 hrc = E_FAIL;
1670 }
1671 RTStrFree(pszProperty);
1672 }
1673 else
1674 {
1675 RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for --nicproperty%d '%s'\n"),
1676 GetOptState.uIndex, ValueUnion.psz);
1677 hrc = E_FAIL;
1678 }
1679 }
1680 break;
1681 }
1682 case MODIFYVM_NICTYPE:
1683 {
1684 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1685 break;
1686
1687 ComPtr<INetworkAdapter> nic;
1688 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1689 ASSERT(nic);
1690
1691 if (!RTStrICmp(ValueUnion.psz, "Am79C970A"))
1692 {
1693 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C970A));
1694 }
1695 else if (!RTStrICmp(ValueUnion.psz, "Am79C973"))
1696 {
1697 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C973));
1698 }
1699 else if (!RTStrICmp(ValueUnion.psz, "Am79C960"))
1700 {
1701 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Am79C960));
1702 }
1703#ifdef VBOX_WITH_E1000
1704 else if (!RTStrICmp(ValueUnion.psz, "82540EM"))
1705 {
1706 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82540EM));
1707 }
1708 else if (!RTStrICmp(ValueUnion.psz, "82543GC"))
1709 {
1710 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82543GC));
1711 }
1712 else if (!RTStrICmp(ValueUnion.psz, "82545EM"))
1713 {
1714 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_I82545EM));
1715 }
1716#endif
1717#ifdef VBOX_WITH_VIRTIO
1718 else if (!RTStrICmp(ValueUnion.psz, "virtio"))
1719 {
1720 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_Virtio));
1721 }
1722#endif /* VBOX_WITH_VIRTIO */
1723 else if (!RTStrICmp(ValueUnion.psz, "NE1000"))
1724 {
1725 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_NE1000));
1726 }
1727 else if (!RTStrICmp(ValueUnion.psz, "NE2000"))
1728 {
1729 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_NE2000));
1730 }
1731 else if (!RTStrICmp(ValueUnion.psz, "WD8003"))
1732 {
1733 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_WD8003));
1734 }
1735 else if (!RTStrICmp(ValueUnion.psz, "WD8013"))
1736 {
1737 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_WD8013));
1738 }
1739 else if (!RTStrICmp(ValueUnion.psz, "3C503"))
1740 {
1741 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_ELNK2));
1742 }
1743 else if (!RTStrICmp(ValueUnion.psz, "3C501"))
1744 {
1745 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_ELNK1));
1746 }
1747 else if (!RTStrICmp(ValueUnion.psz, "usbnet"))
1748 {
1749 CHECK_ERROR(nic, COMSETTER(AdapterType)(NetworkAdapterType_UsbNet));
1750 }
1751 else
1752 {
1753 errorArgument(ModifyVM::tr("Invalid NIC type '%s' specified for NIC %u"),
1754 ValueUnion.psz, GetOptState.uIndex);
1755 hrc = E_FAIL;
1756 }
1757 break;
1758 }
1759
1760 case MODIFYVM_NICSPEED:
1761 {
1762 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1763 break;
1764
1765 ComPtr<INetworkAdapter> nic;
1766 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1767 ASSERT(nic);
1768
1769 CHECK_ERROR(nic, COMSETTER(LineSpeed)(ValueUnion.u32));
1770 break;
1771 }
1772
1773 case MODIFYVM_NICBOOTPRIO:
1774 {
1775 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1776 break;
1777
1778 ComPtr<INetworkAdapter> nic;
1779 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1780 ASSERT(nic);
1781
1782 /* Somewhat arbitrary limitation - we can pass a list of up to 4 PCI devices
1783 * to the PXE ROM, hence only boot priorities 1-4 are allowed (in addition to
1784 * 0 for the default lowest priority).
1785 */
1786 if (ValueUnion.u32 > 4)
1787 {
1788 errorArgument(ModifyVM::tr("Invalid boot priority '%u' specfied for NIC %u"), ValueUnion.u32, GetOptState.uIndex);
1789 hrc = E_FAIL;
1790 }
1791 else
1792 {
1793 CHECK_ERROR(nic, COMSETTER(BootPriority)(ValueUnion.u32));
1794 }
1795 break;
1796 }
1797
1798 case MODIFYVM_NICPROMISC:
1799 {
1800 NetworkAdapterPromiscModePolicy_T enmPromiscModePolicy;
1801 if (!RTStrICmp(ValueUnion.psz, "deny"))
1802 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_Deny;
1803 else if ( !RTStrICmp(ValueUnion.psz, "allow-vms")
1804 || !RTStrICmp(ValueUnion.psz, "allow-network"))
1805 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowNetwork;
1806 else if (!RTStrICmp(ValueUnion.psz, "allow-all"))
1807 enmPromiscModePolicy = NetworkAdapterPromiscModePolicy_AllowAll;
1808 else
1809 {
1810 errorArgument(ModifyVM::tr("Unknown promiscuous mode policy '%s'"), ValueUnion.psz);
1811 hrc = E_INVALIDARG;
1812 break;
1813 }
1814
1815 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1816 break;
1817
1818 ComPtr<INetworkAdapter> nic;
1819 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1820 ASSERT(nic);
1821
1822 CHECK_ERROR(nic, COMSETTER(PromiscModePolicy)(enmPromiscModePolicy));
1823 break;
1824 }
1825
1826 case MODIFYVM_NICBWGROUP:
1827 {
1828 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1829 break;
1830
1831 ComPtr<INetworkAdapter> nic;
1832 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1833 ASSERT(nic);
1834
1835 if (!RTStrICmp(ValueUnion.psz, "none"))
1836 {
1837 /* Just remove the bandwidth group. */
1838 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(NULL));
1839 }
1840 else
1841 {
1842 ComPtr<IBandwidthControl> bwCtrl;
1843 ComPtr<IBandwidthGroup> bwGroup;
1844
1845 CHECK_ERROR(sessionMachine, COMGETTER(BandwidthControl)(bwCtrl.asOutParam()));
1846
1847 if (SUCCEEDED(hrc))
1848 {
1849 CHECK_ERROR(bwCtrl, GetBandwidthGroup(Bstr(ValueUnion.psz).raw(), bwGroup.asOutParam()));
1850 if (SUCCEEDED(hrc))
1851 {
1852 CHECK_ERROR(nic, COMSETTER(BandwidthGroup)(bwGroup));
1853 }
1854 }
1855 }
1856 break;
1857 }
1858
1859 case MODIFYVM_NIC:
1860 {
1861 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1862 break;
1863
1864 ComPtr<INetworkAdapter> nic;
1865 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1866 ASSERT(nic);
1867
1868 /*
1869 * Check if the NIC is already enabled. Do not try to
1870 * enable it if it already is. That makes a
1871 * difference for saved VMs for which you can change
1872 * the NIC attachment, but can't change the NIC
1873 * enabled status (yes, the setter also should not
1874 * freak out about a no-op request).
1875 */
1876 BOOL fEnabled;;
1877 CHECK_ERROR(nic, COMGETTER(Enabled)(&fEnabled));
1878
1879 if (!RTStrICmp(ValueUnion.psz, "none"))
1880 {
1881 if (RT_BOOL(fEnabled))
1882 CHECK_ERROR(nic, COMSETTER(Enabled)(FALSE));
1883 }
1884 else if (!RTStrICmp(ValueUnion.psz, "null"))
1885 {
1886 if (!fEnabled)
1887 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1888 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Null));
1889 }
1890 else if (!RTStrICmp(ValueUnion.psz, "nat"))
1891 {
1892 if (!fEnabled)
1893 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1894 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NAT));
1895 }
1896 else if ( !RTStrICmp(ValueUnion.psz, "bridged")
1897 || !RTStrICmp(ValueUnion.psz, "hostif")) /* backward compatibility */
1898 {
1899 if (!fEnabled)
1900 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1901 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Bridged));
1902 }
1903 else if (!RTStrICmp(ValueUnion.psz, "intnet"))
1904 {
1905 if (!fEnabled)
1906 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1907 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Internal));
1908 }
1909 else if (!RTStrICmp(ValueUnion.psz, "hostonly"))
1910 {
1911 if (!fEnabled)
1912 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1913 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
1914 }
1915#ifdef VBOX_WITH_VMNET
1916 else if (!RTStrICmp(ValueUnion.psz, "hostonlynet"))
1917 {
1918 if (!fEnabled)
1919 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1920 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnlyNetwork));
1921 }
1922#endif /* VBOX_WITH_VMNET */
1923 else if (!RTStrICmp(ValueUnion.psz, "generic"))
1924 {
1925 if (!fEnabled)
1926 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1927 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Generic));
1928 }
1929 else if (!RTStrICmp(ValueUnion.psz, "natnetwork"))
1930 {
1931 if (!fEnabled)
1932 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1933 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_NATNetwork));
1934 }
1935#ifdef VBOX_WITH_CLOUD_NET
1936 else if (!RTStrICmp(ValueUnion.psz, "cloud"))
1937 {
1938 if (!fEnabled)
1939 CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
1940 CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_Cloud));
1941 }
1942#endif /* VBOX_WITH_CLOUD_NET */
1943 else
1944 {
1945 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
1946 hrc = E_FAIL;
1947 }
1948 break;
1949 }
1950
1951 case MODIFYVM_CABLECONNECTED:
1952 {
1953 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1954 break;
1955
1956 ComPtr<INetworkAdapter> nic;
1957 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1958 ASSERT(nic);
1959
1960 CHECK_ERROR(nic, COMSETTER(CableConnected)(ValueUnion.f));
1961 break;
1962 }
1963
1964 case MODIFYVM_BRIDGEADAPTER:
1965 {
1966 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1967 break;
1968
1969 ComPtr<INetworkAdapter> nic;
1970 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1971 ASSERT(nic);
1972
1973 /* remove it? */
1974 if (!RTStrICmp(ValueUnion.psz, "none"))
1975 {
1976 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr().raw()));
1977 }
1978 else
1979 {
1980 CHECK_ERROR(nic, COMSETTER(BridgedInterface)(Bstr(ValueUnion.psz).raw()));
1981 verifyHostNetworkInterfaceName(a->virtualBox, ValueUnion.psz,
1982 HostNetworkInterfaceType_Bridged);
1983 }
1984 break;
1985 }
1986
1987#ifdef VBOX_WITH_CLOUD_NET
1988 case MODIFYVM_CLOUDNET:
1989 {
1990 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
1991 break;
1992
1993 ComPtr<INetworkAdapter> nic;
1994 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
1995 ASSERT(nic);
1996
1997 /* remove it? */
1998 if (!RTStrICmp(ValueUnion.psz, "none"))
1999 {
2000 CHECK_ERROR(nic, COMSETTER(CloudNetwork)(Bstr().raw()));
2001 }
2002 else
2003 {
2004 CHECK_ERROR(nic, COMSETTER(CloudNetwork)(Bstr(ValueUnion.psz).raw()));
2005 }
2006 break;
2007 }
2008#endif /* VBOX_WITH_CLOUD_NET */
2009
2010 case MODIFYVM_HOSTONLYADAPTER:
2011 {
2012 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2013 break;
2014
2015 ComPtr<INetworkAdapter> nic;
2016 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2017 ASSERT(nic);
2018
2019 /* remove it? */
2020 if (!RTStrICmp(ValueUnion.psz, "none"))
2021 {
2022 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr().raw()));
2023 }
2024 else
2025 {
2026 CHECK_ERROR(nic, COMSETTER(HostOnlyInterface)(Bstr(ValueUnion.psz).raw()));
2027 verifyHostNetworkInterfaceName(a->virtualBox, ValueUnion.psz,
2028 HostNetworkInterfaceType_HostOnly);
2029 }
2030 break;
2031 }
2032
2033#ifdef VBOX_WITH_VMNET
2034 case MODIFYVM_HOSTONLYNET:
2035 {
2036 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2037 break;
2038
2039 ComPtr<INetworkAdapter> nic;
2040 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2041 ASSERT(nic);
2042
2043 /* remove it? */
2044 if (!RTStrICmp(ValueUnion.psz, "none"))
2045 {
2046 CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr().raw()));
2047 }
2048 else
2049 {
2050 CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr(ValueUnion.psz).raw()));
2051 }
2052 break;
2053 }
2054#endif /* VBOX_WITH_VMNET */
2055
2056 case MODIFYVM_INTNET:
2057 {
2058 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2059 break;
2060
2061 ComPtr<INetworkAdapter> nic;
2062 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2063 ASSERT(nic);
2064
2065 /* remove it? */
2066 if (!RTStrICmp(ValueUnion.psz, "none"))
2067 {
2068 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr().raw()));
2069 }
2070 else
2071 {
2072 CHECK_ERROR(nic, COMSETTER(InternalNetwork)(Bstr(ValueUnion.psz).raw()));
2073 }
2074 break;
2075 }
2076
2077 case MODIFYVM_GENERICDRV:
2078 {
2079 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2080 break;
2081
2082 ComPtr<INetworkAdapter> nic;
2083 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2084 ASSERT(nic);
2085
2086 CHECK_ERROR(nic, COMSETTER(GenericDriver)(Bstr(ValueUnion.psz).raw()));
2087 break;
2088 }
2089
2090 case MODIFYVM_NATNETWORKNAME:
2091 {
2092 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2093 break;
2094
2095 ComPtr<INetworkAdapter> nic;
2096 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2097 ASSERT(nic);
2098
2099 CHECK_ERROR(nic, COMSETTER(NATNetwork)(Bstr(ValueUnion.psz).raw()));
2100 break;
2101 }
2102
2103 case MODIFYVM_NATNET:
2104 {
2105 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2106 break;
2107
2108 ComPtr<INetworkAdapter> nic;
2109 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2110 ASSERT(nic);
2111
2112 ComPtr<INATEngine> engine;
2113 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2114
2115 const char *psz = ValueUnion.psz;
2116 if (!RTStrICmp("default", psz))
2117 psz = "";
2118
2119 CHECK_ERROR(engine, COMSETTER(Network)(Bstr(psz).raw()));
2120 break;
2121 }
2122
2123 case MODIFYVM_NATBINDIP:
2124 {
2125 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2126 break;
2127
2128 ComPtr<INetworkAdapter> nic;
2129 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2130 ASSERT(nic);
2131
2132 ComPtr<INATEngine> engine;
2133 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2134
2135 CHECK_ERROR(engine, COMSETTER(HostIP)(Bstr(ValueUnion.psz).raw()));
2136 break;
2137 }
2138
2139#define ITERATE_TO_NEXT_TERM(ch) \
2140 do { \
2141 while (*ch != ',') \
2142 { \
2143 if (*ch == 0) \
2144 { \
2145 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"), \
2146 GetOptState.pDef->pszLong); \
2147 } \
2148 ch++; \
2149 } \
2150 *ch = '\0'; \
2151 ch++; \
2152 } while(0)
2153
2154 case MODIFYVM_NATSETTINGS:
2155 {
2156 ComPtr<INetworkAdapter> nic;
2157 ComPtr<INATEngine> engine;
2158 char *strMtu;
2159 char *strSockSnd;
2160 char *strSockRcv;
2161 char *strTcpSnd;
2162 char *strTcpRcv;
2163 char *strRaw = RTStrDup(ValueUnion.psz);
2164 char *ch = strRaw;
2165 strMtu = RTStrStrip(ch);
2166 ITERATE_TO_NEXT_TERM(ch);
2167 strSockSnd = RTStrStrip(ch);
2168 ITERATE_TO_NEXT_TERM(ch);
2169 strSockRcv = RTStrStrip(ch);
2170 ITERATE_TO_NEXT_TERM(ch);
2171 strTcpSnd = RTStrStrip(ch);
2172 ITERATE_TO_NEXT_TERM(ch);
2173 strTcpRcv = RTStrStrip(ch);
2174
2175 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2176 break;
2177
2178 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2179 ASSERT(nic);
2180
2181 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2182 CHECK_ERROR(engine, SetNetworkSettings(RTStrToUInt32(strMtu), RTStrToUInt32(strSockSnd), RTStrToUInt32(strSockRcv),
2183 RTStrToUInt32(strTcpSnd), RTStrToUInt32(strTcpRcv)));
2184 break;
2185 }
2186
2187
2188 case MODIFYVM_NATPF:
2189 {
2190 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2191 break;
2192
2193 ComPtr<INetworkAdapter> nic;
2194 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2195 ASSERT(nic);
2196
2197 ComPtr<INATEngine> engine;
2198 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2199
2200 /* format name:proto:hostip:hostport:guestip:guestport*/
2201 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
2202 {
2203 char *strName;
2204 char *strProto;
2205 char *strHostIp;
2206 char *strHostPort;
2207 char *strGuestIp;
2208 char *strGuestPort;
2209 char *strRaw = RTStrDup(ValueUnion.psz);
2210 char *ch = strRaw;
2211 strName = RTStrStrip(ch);
2212 ITERATE_TO_NEXT_TERM(ch);
2213 strProto = RTStrStrip(ch);
2214 ITERATE_TO_NEXT_TERM(ch);
2215 strHostIp = RTStrStrip(ch);
2216 ITERATE_TO_NEXT_TERM(ch);
2217 strHostPort = RTStrStrip(ch);
2218 ITERATE_TO_NEXT_TERM(ch);
2219 strGuestIp = RTStrStrip(ch);
2220 ITERATE_TO_NEXT_TERM(ch);
2221 strGuestPort = RTStrStrip(ch);
2222 NATProtocol_T proto;
2223 if (RTStrICmp(strProto, "udp") == 0)
2224 proto = NATProtocol_UDP;
2225 else if (RTStrICmp(strProto, "tcp") == 0)
2226 proto = NATProtocol_TCP;
2227 else
2228 {
2229 errorArgument(ModifyVM::tr("Invalid proto '%s' specfied for NIC %u"), ValueUnion.psz, GetOptState.uIndex);
2230 hrc = E_FAIL;
2231 break;
2232 }
2233 CHECK_ERROR(engine, AddRedirect(Bstr(strName).raw(), proto,
2234 Bstr(strHostIp).raw(),
2235 RTStrToUInt16(strHostPort),
2236 Bstr(strGuestIp).raw(),
2237 RTStrToUInt16(strGuestPort)));
2238 }
2239 else
2240 {
2241 /* delete NAT Rule operation */
2242 int vrc;
2243 vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2244 if (RT_FAILURE(vrc))
2245 return errorSyntax(ModifyVM::tr("Not enough parameters"));
2246 CHECK_ERROR(engine, RemoveRedirect(Bstr(ValueUnion.psz).raw()));
2247 }
2248 break;
2249 }
2250 #undef ITERATE_TO_NEXT_TERM
2251 case MODIFYVM_NATALIASMODE:
2252 {
2253 ComPtr<INetworkAdapter> nic;
2254 ComPtr<INATEngine> engine;
2255 uint32_t aliasMode = 0;
2256
2257 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2258 ASSERT(nic);
2259
2260 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2261 if (RTStrCmp(ValueUnion.psz, "default") == 0)
2262 aliasMode = 0;
2263 else
2264 {
2265 char *token = (char *)ValueUnion.psz;
2266 while (token)
2267 {
2268 if (RTStrNCmp(token, RT_STR_TUPLE("log")) == 0)
2269 aliasMode |= NATAliasMode_AliasLog;
2270 else if (RTStrNCmp(token, RT_STR_TUPLE("proxyonly")) == 0)
2271 aliasMode |= NATAliasMode_AliasProxyOnly;
2272 else if (RTStrNCmp(token, RT_STR_TUPLE("sameports")) == 0)
2273 aliasMode |= NATAliasMode_AliasUseSamePorts;
2274 token = RTStrStr(token, ",");
2275 if (token == NULL)
2276 break;
2277 token++;
2278 }
2279 }
2280 CHECK_ERROR(engine, COMSETTER(AliasMode)(aliasMode));
2281 break;
2282 }
2283
2284 case MODIFYVM_NATTFTPPREFIX:
2285 {
2286 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2287 break;
2288
2289 ComPtr<INetworkAdapter> nic;
2290 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2291 ASSERT(nic);
2292
2293 ComPtr<INATEngine> engine;
2294 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2295
2296 CHECK_ERROR(engine, COMSETTER(TFTPPrefix)(Bstr(ValueUnion.psz).raw()));
2297 break;
2298 }
2299
2300 case MODIFYVM_NATTFTPFILE:
2301 {
2302 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2303 break;
2304
2305 ComPtr<INetworkAdapter> nic;
2306 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2307 ASSERT(nic);
2308
2309 ComPtr<INATEngine> engine;
2310 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2311
2312 CHECK_ERROR(engine, COMSETTER(TFTPBootFile)(Bstr(ValueUnion.psz).raw()));
2313 break;
2314 }
2315
2316 case MODIFYVM_NATTFTPSERVER:
2317 {
2318 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2319 break;
2320
2321 ComPtr<INetworkAdapter> nic;
2322 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2323 ASSERT(nic);
2324
2325 ComPtr<INATEngine> engine;
2326 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2327
2328 CHECK_ERROR(engine, COMSETTER(TFTPNextServer)(Bstr(ValueUnion.psz).raw()));
2329 break;
2330 }
2331 case MODIFYVM_NATDNSPASSDOMAIN:
2332 {
2333 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2334 break;
2335
2336 ComPtr<INetworkAdapter> nic;
2337 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2338 ASSERT(nic);
2339
2340 ComPtr<INATEngine> engine;
2341 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2342
2343 CHECK_ERROR(engine, COMSETTER(DNSPassDomain)(ValueUnion.f));
2344 break;
2345 }
2346
2347 case MODIFYVM_NATDNSPROXY:
2348 {
2349 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2350 break;
2351
2352 ComPtr<INetworkAdapter> nic;
2353 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2354 ASSERT(nic);
2355
2356 ComPtr<INATEngine> engine;
2357 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2358
2359 CHECK_ERROR(engine, COMSETTER(DNSProxy)(ValueUnion.f));
2360 break;
2361 }
2362
2363 case MODIFYVM_NATDNSHOSTRESOLVER:
2364 {
2365 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2366 break;
2367
2368 ComPtr<INetworkAdapter> nic;
2369 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2370 ASSERT(nic);
2371
2372 ComPtr<INATEngine> engine;
2373 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2374
2375 CHECK_ERROR(engine, COMSETTER(DNSUseHostResolver)(ValueUnion.f));
2376 break;
2377 }
2378
2379 case MODIFYVM_NATLOCALHOSTREACHABLE:
2380 {
2381 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2382 break;
2383
2384 ComPtr<INetworkAdapter> nic;
2385 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2386 ASSERT(nic);
2387
2388 ComPtr<INATEngine> engine;
2389 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2390
2391 CHECK_ERROR(engine, COMSETTER(LocalhostReachable)(ValueUnion.f));
2392 break;
2393 }
2394
2395 case MODIFYVM_NATFORWARD_BROADCAST:
2396 {
2397 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2398 break;
2399
2400 ComPtr<INetworkAdapter> nic;
2401 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2402 ASSERT(nic);
2403
2404 ComPtr<INATEngine> engine;
2405 CHECK_ERROR(nic, COMGETTER(NATEngine)(engine.asOutParam()));
2406
2407 CHECK_ERROR(engine, COMSETTER(ForwardBroadcast)(ValueUnion.f));
2408 break;
2409 }
2410
2411 case MODIFYVM_MACADDRESS:
2412 {
2413 if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
2414 break;
2415
2416 ComPtr<INetworkAdapter> nic;
2417 CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
2418 ASSERT(nic);
2419
2420 /* generate one? */
2421 if (!RTStrICmp(ValueUnion.psz, "auto"))
2422 {
2423 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr().raw()));
2424 }
2425 else
2426 {
2427 CHECK_ERROR(nic, COMSETTER(MACAddress)(Bstr(ValueUnion.psz).raw()));
2428 }
2429 break;
2430 }
2431
2432 case MODIFYVM_HIDPTR:
2433 {
2434 bool fEnableUsb = false;
2435 if (!RTStrICmp(ValueUnion.psz, "ps2"))
2436 {
2437 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_PS2Mouse));
2438 }
2439 else if (!RTStrICmp(ValueUnion.psz, "usb"))
2440 {
2441 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMouse));
2442 if (SUCCEEDED(hrc))
2443 fEnableUsb = true;
2444 }
2445 else if (!RTStrICmp(ValueUnion.psz, "usbtablet"))
2446 {
2447 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBTablet));
2448 if (SUCCEEDED(hrc))
2449 fEnableUsb = true;
2450 }
2451 else if (!RTStrICmp(ValueUnion.psz, "usbmultitouch"))
2452 {
2453 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouch));
2454 if (SUCCEEDED(hrc))
2455 fEnableUsb = true;
2456 }
2457 else if (!RTStrICmp(ValueUnion.psz, "usbmtscreenpluspad"))
2458 {
2459 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_USBMultiTouchScreenPlusPad));
2460 if (SUCCEEDED(hrc))
2461 fEnableUsb = true;
2462 }
2463 else if (!RTStrICmp(ValueUnion.psz, "none"))
2464 {
2465 CHECK_ERROR(sessionMachine, COMSETTER(PointingHIDType)(PointingHIDType_None));
2466 }
2467 else
2468 {
2469 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for pointing device"), ValueUnion.psz);
2470 hrc = E_FAIL;
2471 }
2472 if (fEnableUsb)
2473 {
2474 /* Make sure either the OHCI or xHCI controller is enabled. */
2475 ULONG cOhciCtrls = 0;
2476 ULONG cXhciCtrls = 0;
2477 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2478 if (SUCCEEDED(hrc)) {
2479 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2480 if ( SUCCEEDED(hrc)
2481 && cOhciCtrls + cXhciCtrls == 0)
2482 {
2483 /* If there's nothing, enable OHCI (always available). */
2484 ComPtr<IUSBController> UsbCtl;
2485 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2486 UsbCtl.asOutParam()));
2487 }
2488 }
2489 }
2490 break;
2491 }
2492
2493 case MODIFYVM_HIDKBD:
2494 {
2495 bool fEnableUsb = false;
2496 if (!RTStrICmp(ValueUnion.psz, "ps2"))
2497 {
2498 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_PS2Keyboard));
2499 }
2500 else if (!RTStrICmp(ValueUnion.psz, "usb"))
2501 {
2502 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_USBKeyboard));
2503 if (SUCCEEDED(hrc))
2504 fEnableUsb = true;
2505 }
2506 else if (!RTStrICmp(ValueUnion.psz, "none"))
2507 {
2508 CHECK_ERROR(sessionMachine, COMSETTER(KeyboardHIDType)(KeyboardHIDType_None));
2509 if (SUCCEEDED(hrc))
2510 fEnableUsb = true;
2511 }
2512 else
2513 {
2514 errorArgument(ModifyVM::tr("Invalid type '%s' specfied for keyboard"), ValueUnion.psz);
2515 hrc = E_FAIL;
2516 }
2517 if (fEnableUsb)
2518 {
2519 /* Make sure either the OHCI or xHCI controller is enabled. */
2520 ULONG cOhciCtrls = 0;
2521 ULONG cXhciCtrls = 0;
2522 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
2523 if (SUCCEEDED(hrc)) {
2524 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
2525 if ( SUCCEEDED(hrc)
2526 && cOhciCtrls + cXhciCtrls == 0)
2527 {
2528 /* If there's nothing, enable OHCI (always available). */
2529 ComPtr<IUSBController> UsbCtl;
2530 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
2531 UsbCtl.asOutParam()));
2532 }
2533 }
2534 }
2535 break;
2536 }
2537
2538 case MODIFYVM_UARTMODE:
2539 {
2540 ComPtr<ISerialPort> uart;
2541
2542 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2543 ASSERT(uart);
2544
2545 if (!RTStrICmp(ValueUnion.psz, "disconnected"))
2546 {
2547 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_Disconnected));
2548 }
2549 else if ( !RTStrICmp(ValueUnion.psz, "server")
2550 || !RTStrICmp(ValueUnion.psz, "client")
2551 || !RTStrICmp(ValueUnion.psz, "tcpserver")
2552 || !RTStrICmp(ValueUnion.psz, "tcpclient")
2553 || !RTStrICmp(ValueUnion.psz, "file"))
2554 {
2555 const char *pszMode = ValueUnion.psz;
2556
2557 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
2558 if (RT_FAILURE(vrc))
2559 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2560 GetOptState.pDef->pszLong);
2561
2562 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2563
2564 if (!RTStrICmp(pszMode, "server"))
2565 {
2566 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2567 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2568 }
2569 else if (!RTStrICmp(pszMode, "client"))
2570 {
2571 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostPipe));
2572 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2573 }
2574 else if (!RTStrICmp(pszMode, "tcpserver"))
2575 {
2576 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2577 CHECK_ERROR(uart, COMSETTER(Server)(TRUE));
2578 }
2579 else if (!RTStrICmp(pszMode, "tcpclient"))
2580 {
2581 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_TCP));
2582 CHECK_ERROR(uart, COMSETTER(Server)(FALSE));
2583 }
2584 else if (!RTStrICmp(pszMode, "file"))
2585 {
2586 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_RawFile));
2587 }
2588 }
2589 else
2590 {
2591 CHECK_ERROR(uart, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2592 CHECK_ERROR(uart, COMSETTER(HostMode)(PortMode_HostDevice));
2593 }
2594 break;
2595 }
2596
2597 case MODIFYVM_UARTTYPE:
2598 {
2599 ComPtr<ISerialPort> uart;
2600
2601 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2602 ASSERT(uart);
2603
2604 if (!RTStrICmp(ValueUnion.psz, "16450"))
2605 {
2606 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16450));
2607 }
2608 else if (!RTStrICmp(ValueUnion.psz, "16550A"))
2609 {
2610 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16550A));
2611 }
2612 else if (!RTStrICmp(ValueUnion.psz, "16750"))
2613 {
2614 CHECK_ERROR(uart, COMSETTER(UartType)(UartType_U16750));
2615 }
2616 else
2617 return errorSyntax(ModifyVM::tr("Invalid argument to '%s'"),
2618 GetOptState.pDef->pszLong);
2619 break;
2620 }
2621
2622 case MODIFYVM_UART:
2623 {
2624 ComPtr<ISerialPort> uart;
2625
2626 CHECK_ERROR_BREAK(sessionMachine, GetSerialPort(GetOptState.uIndex - 1, uart.asOutParam()));
2627 ASSERT(uart);
2628
2629 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
2630 CHECK_ERROR(uart, COMSETTER(Enabled)(FALSE));
2631 else
2632 {
2633 const char *pszIOBase = ValueUnion.psz;
2634 uint32_t uVal = 0;
2635
2636 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_UART;
2637 if (RT_FAILURE(vrc))
2638 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2639 GetOptState.pDef->pszLong);
2640
2641 CHECK_ERROR(uart, COMSETTER(IRQ)(ValueUnion.u32));
2642
2643 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2644 if (vrc != VINF_SUCCESS || uVal == 0)
2645 return errorArgument(ModifyVM::tr("Error parsing UART I/O base '%s'"), pszIOBase);
2646 CHECK_ERROR(uart, COMSETTER(IOAddress)(uVal));
2647
2648 CHECK_ERROR(uart, COMSETTER(Enabled)(TRUE));
2649 }
2650 break;
2651 }
2652
2653#if defined(RT_OS_LINUX) || defined(RT_OS_WINDOWS)
2654 case MODIFYVM_LPTMODE:
2655 {
2656 ComPtr<IParallelPort> lpt;
2657
2658 CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2659 ASSERT(lpt);
2660
2661 CHECK_ERROR(lpt, COMSETTER(Path)(Bstr(ValueUnion.psz).raw()));
2662 break;
2663 }
2664
2665 case MODIFYVM_LPT:
2666 {
2667 ComPtr<IParallelPort> lpt;
2668
2669 CHECK_ERROR_BREAK(sessionMachine, GetParallelPort(GetOptState.uIndex - 1, lpt.asOutParam()));
2670 ASSERT(lpt);
2671
2672 if (!RTStrICmp(ValueUnion.psz, "off") || !RTStrICmp(ValueUnion.psz, "disable"))
2673 CHECK_ERROR(lpt, COMSETTER(Enabled)(FALSE));
2674 else
2675 {
2676 const char *pszIOBase = ValueUnion.psz;
2677 uint32_t uVal = 0;
2678
2679 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_UINT32) != MODIFYVM_LPT;
2680 if (RT_FAILURE(vrc))
2681 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
2682 GetOptState.pDef->pszLong);
2683
2684 CHECK_ERROR(lpt, COMSETTER(IRQ)(ValueUnion.u32));
2685
2686 vrc = RTStrToUInt32Ex(pszIOBase, NULL, 0, &uVal);
2687 if (vrc != VINF_SUCCESS || uVal == 0)
2688 return errorArgument(ModifyVM::tr("Error parsing LPT I/O base '%s'"), pszIOBase);
2689 CHECK_ERROR(lpt, COMSETTER(IOBase)(uVal));
2690
2691 CHECK_ERROR(lpt, COMSETTER(Enabled)(TRUE));
2692 }
2693 break;
2694 }
2695#endif
2696
2697 case MODIFYVM_GUESTMEMORYBALLOON:
2698 {
2699 CHECK_ERROR(sessionMachine, COMSETTER(MemoryBalloonSize)(ValueUnion.u32));
2700 break;
2701 }
2702
2703 case MODIFYVM_AUDIOCONTROLLER:
2704 {
2705 ComPtr<IAudioSettings> audioSettings;
2706 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2707 ComPtr<IAudioAdapter> audioAdapter;
2708 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2709 ASSERT(audioAdapter);
2710
2711 if (!RTStrICmp(ValueUnion.psz, "sb16"))
2712 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_SB16));
2713 else if (!RTStrICmp(ValueUnion.psz, "ac97"))
2714 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_AC97));
2715 else if (!RTStrICmp(ValueUnion.psz, "hda"))
2716 CHECK_ERROR(audioAdapter, COMSETTER(AudioController)(AudioControllerType_HDA));
2717 else
2718 {
2719 errorArgument(ModifyVM::tr("Invalid --audiocontroller argument '%s'"), ValueUnion.psz);
2720 hrc = E_FAIL;
2721 }
2722 break;
2723 }
2724
2725 case MODIFYVM_AUDIOCODEC:
2726 {
2727 ComPtr<IAudioSettings> audioSettings;
2728 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2729 ComPtr<IAudioAdapter> audioAdapter;
2730 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2731 ASSERT(audioAdapter);
2732
2733 if (!RTStrICmp(ValueUnion.psz, "sb16"))
2734 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_SB16));
2735 else if (!RTStrICmp(ValueUnion.psz, "stac9700"))
2736 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9700));
2737 else if (!RTStrICmp(ValueUnion.psz, "ad1980"))
2738 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_AD1980));
2739 else if (!RTStrICmp(ValueUnion.psz, "stac9221"))
2740 CHECK_ERROR(audioAdapter, COMSETTER(AudioCodec)(AudioCodecType_STAC9221));
2741 else
2742 {
2743 errorArgument(ModifyVM::tr("Invalid --audiocodec argument '%s'"), ValueUnion.psz);
2744 hrc = E_FAIL;
2745 }
2746 break;
2747 }
2748
2749 case MODIFYVM_AUDIODRIVER:
2750 RT_FALL_THROUGH();
2751 case MODIFYVM_AUDIO: /** @todo Deprecated; remove. */
2752 {
2753 if (c == MODIFYVM_AUDIO)
2754 RTStrmPrintf(g_pStdErr,
2755 ModifyVM::tr("Warning: --audio is deprecated and will be removed soon. Use --audio-driver instead!\n"));
2756
2757 ComPtr<IAudioSettings> audioSettings;
2758 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2759 ComPtr<IAudioAdapter> audioAdapter;
2760 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2761 ASSERT(audioAdapter);
2762 /* disable? */
2763 if ( !RTStrICmp(ValueUnion.psz, "none")
2764 || !RTStrICmp(ValueUnion.psz, "null"))
2765 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Null));
2766 else if (!RTStrICmp(ValueUnion.psz, "default"))
2767 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Default));
2768#ifdef RT_OS_WINDOWS
2769 else if (!RTStrICmp(ValueUnion.psz, "dsound"))
2770 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_DirectSound));
2771 else if (!RTStrICmp(ValueUnion.psz, "was"))
2772 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_WAS));
2773#endif /* RT_OS_WINDOWS */
2774#ifdef VBOX_WITH_AUDIO_OSS
2775 else if (!RTStrICmp(ValueUnion.psz, "oss"))
2776 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_OSS));
2777#endif
2778#ifdef VBOX_WITH_AUDIO_ALSA
2779 else if (!RTStrICmp(ValueUnion.psz, "alsa"))
2780 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_ALSA));
2781#endif
2782#ifdef VBOX_WITH_AUDIO_PULSE
2783 else if (!RTStrICmp(ValueUnion.psz, "pulse"))
2784 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_Pulse));
2785#endif
2786#ifdef RT_OS_DARWIN
2787 else if (!RTStrICmp(ValueUnion.psz, "coreaudio"))
2788 CHECK_ERROR(audioAdapter, COMSETTER(AudioDriver)(AudioDriverType_CoreAudio));
2789#endif /* !RT_OS_DARWIN */
2790 else
2791 {
2792 errorArgument(ModifyVM::tr("Invalid %s argument '%s'"),
2793 c == MODIFYVM_AUDIO ? "--audio" : "--audio-driver", ValueUnion.psz);
2794 hrc = E_FAIL;
2795 }
2796
2797 if ( SUCCEEDED(hrc)
2798 && c == MODIFYVM_AUDIO) /* To keep the original behavior until we remove the command. */
2799 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(RTStrICmp(ValueUnion.psz, "none") == false ? false : true));
2800
2801 break;
2802 }
2803
2804 case MODIFYVM_AUDIOENABLED:
2805 {
2806 ComPtr<IAudioSettings> audioSettings;
2807 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2808 ComPtr<IAudioAdapter> audioAdapter;
2809 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2810 ASSERT(audioAdapter);
2811
2812 CHECK_ERROR(audioAdapter, COMSETTER(Enabled)(ValueUnion.f));
2813 break;
2814 }
2815
2816 case MODIFYVM_AUDIOIN:
2817 {
2818 ComPtr<IAudioSettings> audioSettings;
2819 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2820 ComPtr<IAudioAdapter> audioAdapter;
2821 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2822 ASSERT(audioAdapter);
2823
2824 CHECK_ERROR(audioAdapter, COMSETTER(EnabledIn)(ValueUnion.f));
2825 break;
2826 }
2827
2828 case MODIFYVM_AUDIOOUT:
2829 {
2830 ComPtr<IAudioSettings> audioSettings;
2831 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(AudioSettings)(audioSettings.asOutParam()));
2832 ComPtr<IAudioAdapter> audioAdapter;
2833 CHECK_ERROR_BREAK(audioSettings, COMGETTER(Adapter)(audioAdapter.asOutParam()));
2834 ASSERT(audioAdapter);
2835
2836 CHECK_ERROR(audioAdapter, COMSETTER(EnabledOut)(ValueUnion.f));
2837 break;
2838 }
2839
2840#ifdef VBOX_WITH_SHARED_CLIPBOARD
2841 case MODIFYVM_CLIPBOARD_MODE:
2842 {
2843 ClipboardMode_T mode = ClipboardMode_Disabled; /* Shut up MSC */
2844 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2845 mode = ClipboardMode_Disabled;
2846 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2847 mode = ClipboardMode_HostToGuest;
2848 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2849 mode = ClipboardMode_GuestToHost;
2850 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2851 mode = ClipboardMode_Bidirectional;
2852 else
2853 {
2854 errorArgument(ModifyVM::tr("Invalid --clipboard-mode argument '%s'"), ValueUnion.psz);
2855 hrc = E_FAIL;
2856 }
2857 if (SUCCEEDED(hrc))
2858 {
2859 CHECK_ERROR(sessionMachine, COMSETTER(ClipboardMode)(mode));
2860 }
2861 break;
2862 }
2863
2864# ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
2865 case MODIFYVM_CLIPBOARD_FILE_TRANSFERS:
2866 {
2867 BOOL fEnabled = false; /* Shut up MSC */
2868 if (!RTStrICmp(ValueUnion.psz, "enabled"))
2869 fEnabled = true;
2870 else if (!RTStrICmp(ValueUnion.psz, "disabled"))
2871 fEnabled = false;
2872 else
2873 {
2874 errorArgument(ModifyVM::tr("Invalid --clipboard-file-transfers argument '%s'"), ValueUnion.psz);
2875 hrc = E_FAIL;
2876 }
2877 if (SUCCEEDED(hrc))
2878 {
2879 CHECK_ERROR(sessionMachine, COMSETTER(ClipboardFileTransfersEnabled)(fEnabled));
2880 }
2881 break;
2882 }
2883# endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
2884#endif /* VBOX_WITH_SHARED_CLIPBOARD */
2885
2886 case MODIFYVM_DRAGANDDROP:
2887 {
2888 DnDMode_T mode = DnDMode_Disabled; /* Shut up MSC */
2889 if (!RTStrICmp(ValueUnion.psz, "disabled"))
2890 mode = DnDMode_Disabled;
2891 else if (!RTStrICmp(ValueUnion.psz, "hosttoguest"))
2892 mode = DnDMode_HostToGuest;
2893 else if (!RTStrICmp(ValueUnion.psz, "guesttohost"))
2894 mode = DnDMode_GuestToHost;
2895 else if (!RTStrICmp(ValueUnion.psz, "bidirectional"))
2896 mode = DnDMode_Bidirectional;
2897 else
2898 {
2899 errorArgument(ModifyVM::tr("Invalid --draganddrop argument '%s'"), ValueUnion.psz);
2900 hrc = E_FAIL;
2901 }
2902 if (SUCCEEDED(hrc))
2903 {
2904 CHECK_ERROR(sessionMachine, COMSETTER(DnDMode)(mode));
2905 }
2906 break;
2907 }
2908
2909 case MODIFYVM_VRDE_EXTPACK:
2910 {
2911 ComPtr<IVRDEServer> vrdeServer;
2912 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2913 ASSERT(vrdeServer);
2914
2915 if (vrdeServer)
2916 {
2917 if (RTStrICmp(ValueUnion.psz, "default") != 0)
2918 {
2919 Bstr bstr(ValueUnion.psz);
2920 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(bstr.raw()));
2921 }
2922 else
2923 CHECK_ERROR(vrdeServer, COMSETTER(VRDEExtPack)(Bstr().raw()));
2924 }
2925 break;
2926 }
2927
2928 case MODIFYVM_VRDEPROPERTY:
2929 {
2930 ComPtr<IVRDEServer> vrdeServer;
2931 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2932 ASSERT(vrdeServer);
2933
2934 if (vrdeServer)
2935 {
2936 /* Parse 'name=value' */
2937 char *pszProperty = RTStrDup(ValueUnion.psz);
2938 if (pszProperty)
2939 {
2940 char *pDelimiter = strchr(pszProperty, '=');
2941 if (pDelimiter)
2942 {
2943 *pDelimiter = '\0';
2944
2945 Bstr bstrName = pszProperty;
2946 Bstr bstrValue = &pDelimiter[1];
2947 CHECK_ERROR(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
2948 }
2949 else
2950 {
2951 RTStrFree(pszProperty);
2952
2953 errorArgument(ModifyVM::tr("Invalid --vrdeproperty argument '%s'"), ValueUnion.psz);
2954 hrc = E_FAIL;
2955 break;
2956 }
2957 RTStrFree(pszProperty);
2958 }
2959 else
2960 {
2961 RTStrmPrintf(g_pStdErr, ModifyVM::tr("Error: Failed to allocate memory for VRDE property '%s'\n"),
2962 ValueUnion.psz);
2963 hrc = E_FAIL;
2964 }
2965 }
2966 break;
2967 }
2968
2969 case MODIFYVM_VRDPPORT:
2970 vrdeWarningDeprecatedOption("port");
2971 RT_FALL_THRU();
2972
2973 case MODIFYVM_VRDEPORT:
2974 {
2975 ComPtr<IVRDEServer> vrdeServer;
2976 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2977 ASSERT(vrdeServer);
2978
2979 if (!RTStrICmp(ValueUnion.psz, "default"))
2980 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr("0").raw()));
2981 else
2982 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), Bstr(ValueUnion.psz).raw()));
2983 break;
2984 }
2985
2986 case MODIFYVM_VRDPADDRESS:
2987 vrdeWarningDeprecatedOption("address");
2988 RT_FALL_THRU();
2989
2990 case MODIFYVM_VRDEADDRESS:
2991 {
2992 ComPtr<IVRDEServer> vrdeServer;
2993 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
2994 ASSERT(vrdeServer);
2995
2996 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(ValueUnion.psz).raw()));
2997 break;
2998 }
2999
3000 case MODIFYVM_VRDPAUTHTYPE:
3001 vrdeWarningDeprecatedOption("authtype");
3002 RT_FALL_THRU();
3003 case MODIFYVM_VRDEAUTHTYPE:
3004 {
3005 ComPtr<IVRDEServer> vrdeServer;
3006 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3007 ASSERT(vrdeServer);
3008
3009 if (!RTStrICmp(ValueUnion.psz, "null"))
3010 {
3011 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Null));
3012 }
3013 else if (!RTStrICmp(ValueUnion.psz, "external"))
3014 {
3015 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_External));
3016 }
3017 else if (!RTStrICmp(ValueUnion.psz, "guest"))
3018 {
3019 CHECK_ERROR(vrdeServer, COMSETTER(AuthType)(AuthType_Guest));
3020 }
3021 else
3022 {
3023 errorArgument(ModifyVM::tr("Invalid --vrdeauthtype argument '%s'"), ValueUnion.psz);
3024 hrc = E_FAIL;
3025 }
3026 break;
3027 }
3028
3029 case MODIFYVM_VRDEAUTHLIBRARY:
3030 {
3031 ComPtr<IVRDEServer> vrdeServer;
3032 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3033 ASSERT(vrdeServer);
3034
3035 if (vrdeServer)
3036 {
3037 if (RTStrICmp(ValueUnion.psz, "default") != 0)
3038 {
3039 Bstr bstr(ValueUnion.psz);
3040 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(bstr.raw()));
3041 }
3042 else
3043 CHECK_ERROR(vrdeServer, COMSETTER(AuthLibrary)(Bstr().raw()));
3044 }
3045 break;
3046 }
3047
3048 case MODIFYVM_VRDPMULTICON:
3049 vrdeWarningDeprecatedOption("multicon");
3050 RT_FALL_THRU();
3051 case MODIFYVM_VRDEMULTICON:
3052 {
3053 ComPtr<IVRDEServer> vrdeServer;
3054 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3055 ASSERT(vrdeServer);
3056
3057 CHECK_ERROR(vrdeServer, COMSETTER(AllowMultiConnection)(ValueUnion.f));
3058 break;
3059 }
3060
3061 case MODIFYVM_VRDPREUSECON:
3062 vrdeWarningDeprecatedOption("reusecon");
3063 RT_FALL_THRU();
3064 case MODIFYVM_VRDEREUSECON:
3065 {
3066 ComPtr<IVRDEServer> vrdeServer;
3067 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3068 ASSERT(vrdeServer);
3069
3070 CHECK_ERROR(vrdeServer, COMSETTER(ReuseSingleConnection)(ValueUnion.f));
3071 break;
3072 }
3073
3074 case MODIFYVM_VRDPVIDEOCHANNEL:
3075 vrdeWarningDeprecatedOption("videochannel");
3076 RT_FALL_THRU();
3077 case MODIFYVM_VRDEVIDEOCHANNEL:
3078 {
3079 ComPtr<IVRDEServer> vrdeServer;
3080 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3081 ASSERT(vrdeServer);
3082
3083 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Enabled").raw(),
3084 ValueUnion.f? Bstr("true").raw(): Bstr("false").raw()));
3085 break;
3086 }
3087
3088 case MODIFYVM_VRDPVIDEOCHANNELQUALITY:
3089 vrdeWarningDeprecatedOption("videochannelquality");
3090 RT_FALL_THRU();
3091 case MODIFYVM_VRDEVIDEOCHANNELQUALITY:
3092 {
3093 ComPtr<IVRDEServer> vrdeServer;
3094 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3095 ASSERT(vrdeServer);
3096
3097 CHECK_ERROR(vrdeServer, SetVRDEProperty(Bstr("VideoChannel/Quality").raw(),
3098 Bstr(ValueUnion.psz).raw()));
3099 break;
3100 }
3101
3102 case MODIFYVM_VRDP:
3103 vrdeWarningDeprecatedOption("");
3104 RT_FALL_THRU();
3105 case MODIFYVM_VRDE:
3106 {
3107 ComPtr<IVRDEServer> vrdeServer;
3108 sessionMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
3109 ASSERT(vrdeServer);
3110
3111 CHECK_ERROR(vrdeServer, COMSETTER(Enabled)(ValueUnion.f));
3112 break;
3113 }
3114
3115 case MODIFYVM_USBRENAME:
3116 {
3117 const char *pszName = ValueUnion.psz;
3118 int vrc = RTGetOptFetchValue(&GetOptState, &ValueUnion, RTGETOPT_REQ_STRING);
3119 if (RT_FAILURE(vrc))
3120 return errorSyntax(ModifyVM::tr("Missing or invalid argument to '%s'"),
3121 GetOptState.pDef->pszLong);
3122 const char *pszNewName = ValueUnion.psz;
3123
3124 SafeIfaceArray<IUSBController> ctrls;
3125 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3126 bool fRenamed = false;
3127 for (size_t i = 0; i < ctrls.size(); i++)
3128 {
3129 ComPtr<IUSBController> pCtrl = ctrls[i];
3130 Bstr bstrName;
3131 CHECK_ERROR(pCtrl, COMGETTER(Name)(bstrName.asOutParam()));
3132 if (bstrName == pszName)
3133 {
3134 bstrName = pszNewName;
3135 CHECK_ERROR(pCtrl, COMSETTER(Name)(bstrName.raw()));
3136 fRenamed = true;
3137 }
3138 }
3139 if (!fRenamed)
3140 {
3141 errorArgument(ModifyVM::tr("Invalid --usbrename parameters, nothing renamed"));
3142 hrc = E_FAIL;
3143 }
3144 break;
3145 }
3146
3147 case MODIFYVM_USBXHCI:
3148 {
3149 ULONG cXhciCtrls = 0;
3150 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_XHCI, &cXhciCtrls);
3151 if (SUCCEEDED(hrc))
3152 {
3153 if (!cXhciCtrls && ValueUnion.f)
3154 {
3155 ComPtr<IUSBController> UsbCtl;
3156 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("xHCI").raw(), USBControllerType_XHCI,
3157 UsbCtl.asOutParam()));
3158 }
3159 else if (cXhciCtrls && !ValueUnion.f)
3160 {
3161 SafeIfaceArray<IUSBController> ctrls;
3162 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3163 for (size_t i = 0; i < ctrls.size(); i++)
3164 {
3165 ComPtr<IUSBController> pCtrl = ctrls[i];
3166 USBControllerType_T enmType;
3167 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3168 if (enmType == USBControllerType_XHCI)
3169 {
3170 Bstr ctrlName;
3171 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3172 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3173 }
3174 }
3175 }
3176 }
3177 break;
3178 }
3179
3180 case MODIFYVM_USBEHCI:
3181 {
3182 ULONG cEhciCtrls = 0;
3183 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_EHCI, &cEhciCtrls);
3184 if (SUCCEEDED(hrc))
3185 {
3186 if (!cEhciCtrls && ValueUnion.f)
3187 {
3188 ComPtr<IUSBController> UsbCtl;
3189 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("EHCI").raw(), USBControllerType_EHCI,
3190 UsbCtl.asOutParam()));
3191 }
3192 else if (cEhciCtrls && !ValueUnion.f)
3193 {
3194 SafeIfaceArray<IUSBController> ctrls;
3195 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3196 for (size_t i = 0; i < ctrls.size(); i++)
3197 {
3198 ComPtr<IUSBController> pCtrl = ctrls[i];
3199 USBControllerType_T enmType;
3200 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3201 if (enmType == USBControllerType_EHCI)
3202 {
3203 Bstr ctrlName;
3204 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3205 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3206 }
3207 }
3208 }
3209 }
3210 break;
3211 }
3212
3213 case MODIFYVM_USBOHCI:
3214 {
3215 ULONG cOhciCtrls = 0;
3216 hrc = sessionMachine->GetUSBControllerCountByType(USBControllerType_OHCI, &cOhciCtrls);
3217 if (SUCCEEDED(hrc))
3218 {
3219 if (!cOhciCtrls && ValueUnion.f)
3220 {
3221 ComPtr<IUSBController> UsbCtl;
3222 CHECK_ERROR(sessionMachine, AddUSBController(Bstr("OHCI").raw(), USBControllerType_OHCI,
3223 UsbCtl.asOutParam()));
3224 }
3225 else if (cOhciCtrls && !ValueUnion.f)
3226 {
3227 SafeIfaceArray<IUSBController> ctrls;
3228 CHECK_ERROR(sessionMachine, COMGETTER(USBControllers)(ComSafeArrayAsOutParam(ctrls)));
3229 for (size_t i = 0; i < ctrls.size(); i++)
3230 {
3231 ComPtr<IUSBController> pCtrl = ctrls[i];
3232 USBControllerType_T enmType;
3233 CHECK_ERROR(pCtrl, COMGETTER(Type)(&enmType));
3234 if (enmType == USBControllerType_OHCI)
3235 {
3236 Bstr ctrlName;
3237 CHECK_ERROR(pCtrl, COMGETTER(Name)(ctrlName.asOutParam()));
3238 CHECK_ERROR(sessionMachine, RemoveUSBController(ctrlName.raw()));
3239 }
3240 }
3241 }
3242 }
3243 break;
3244 }
3245
3246 case MODIFYVM_SNAPSHOTFOLDER:
3247 {
3248 if (!RTStrICmp(ValueUnion.psz, "default"))
3249 CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr().raw()));
3250 else
3251 CHECK_ERROR(sessionMachine, COMSETTER(SnapshotFolder)(Bstr(ValueUnion.psz).raw()));
3252 break;
3253 }
3254
3255 case MODIFYVM_TELEPORTER_ENABLED:
3256 {
3257 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterEnabled)(ValueUnion.f));
3258 break;
3259 }
3260
3261 case MODIFYVM_TELEPORTER_PORT:
3262 {
3263 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPort)(ValueUnion.u32));
3264 break;
3265 }
3266
3267 case MODIFYVM_TELEPORTER_ADDRESS:
3268 {
3269 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterAddress)(Bstr(ValueUnion.psz).raw()));
3270 break;
3271 }
3272
3273 case MODIFYVM_TELEPORTER_PASSWORD:
3274 {
3275 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(ValueUnion.psz).raw()));
3276 break;
3277 }
3278
3279 case MODIFYVM_TELEPORTER_PASSWORD_FILE:
3280 {
3281 Utf8Str password;
3282 RTEXITCODE rcExit = readPasswordFile(ValueUnion.psz, &password);
3283 if (rcExit != RTEXITCODE_SUCCESS)
3284 hrc = E_FAIL;
3285 else
3286 CHECK_ERROR(sessionMachine, COMSETTER(TeleporterPassword)(Bstr(password).raw()));
3287 break;
3288 }
3289
3290 case MODIFYVM_TRACING_ENABLED:
3291 {
3292 CHECK_ERROR(sessionMachine, COMSETTER(TracingEnabled)(ValueUnion.f));
3293 break;
3294 }
3295
3296 case MODIFYVM_TRACING_CONFIG:
3297 {
3298 CHECK_ERROR(sessionMachine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
3299 break;
3300 }
3301
3302 case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
3303 {
3304 CHECK_ERROR(sessionMachine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
3305 break;
3306 }
3307
3308 case MODIFYVM_HARDWARE_UUID:
3309 {
3310 CHECK_ERROR(sessionMachine, COMSETTER(HardwareUUID)(Bstr(ValueUnion.psz).raw()));
3311 break;
3312 }
3313
3314 case MODIFYVM_IOCACHE:
3315 {
3316 CHECK_ERROR(sessionMachine, COMSETTER(IOCacheEnabled)(ValueUnion.f));
3317 break;
3318 }
3319
3320 case MODIFYVM_IOCACHESIZE:
3321 {
3322 CHECK_ERROR(sessionMachine, COMSETTER(IOCacheSize)(ValueUnion.u32));
3323 break;
3324 }
3325
3326 case MODIFYVM_CHIPSET:
3327 {
3328 if (!RTStrICmp(ValueUnion.psz, "piix3"))
3329 {
3330 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_PIIX3));
3331 }
3332 else if (!RTStrICmp(ValueUnion.psz, "ich9"))
3333 {
3334 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_ICH9));
3335 BOOL fIoApic = FALSE;
3336 CHECK_ERROR(firmwareSettings, COMGETTER(IOAPICEnabled)(&fIoApic));
3337 if (!fIoApic)
3338 {
3339 RTStrmPrintf(g_pStdErr, ModifyVM::tr("*** I/O APIC must be enabled for ICH9, enabling. ***\n"));
3340 CHECK_ERROR(firmwareSettings, COMSETTER(IOAPICEnabled)(TRUE));
3341 }
3342 }
3343 else if ( !RTStrICmp(ValueUnion.psz, "armv8")
3344 || !RTStrICmp(ValueUnion.psz, "armv8virtual"))
3345 {
3346 CHECK_ERROR(platform, COMSETTER(ChipsetType)(ChipsetType_ARMv8Virtual));
3347 }
3348 else
3349 {
3350 errorArgument(ModifyVM::tr("Invalid --chipset argument '%s' (valid: piix3,ich9,armv8virtual)"),
3351 ValueUnion.psz);
3352 hrc = E_FAIL;
3353 }
3354 break;
3355 }
3356#if defined(VBOX_WITH_IOMMU_AMD) || defined(VBOX_WITH_IOMMU_INTEL)
3357 case MODIFYVM_IOMMU:
3358 {
3359 if ( !RTStrICmp(ValueUnion.psz, "none")
3360 || !RTStrICmp(ValueUnion.psz, "disabled"))
3361 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_None));
3362 else if (!RTStrICmp(ValueUnion.psz, "amd"))
3363 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_AMD));
3364 else if (!RTStrICmp(ValueUnion.psz, "intel"))
3365 {
3366#ifdef VBOX_WITH_IOMMU_INTEL
3367 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Intel));
3368#else
3369 errorArgument(ModifyVM::tr("Invalid --iommu argument '%s' (valid: none,amd,automatic)"), ValueUnion.psz);
3370 hrc = E_FAIL;
3371#endif
3372 }
3373 else if (!RTStrICmp(ValueUnion.psz, "automatic"))
3374 {
3375 CHECK_ERROR(platform, COMSETTER(IommuType)(IommuType_Automatic));
3376#ifndef VBOX_WITH_IOMMU_INTEL
3377 RTStrmPrintf(g_pStdErr,
3378 ModifyVM::tr("Warning: On Intel hosts, 'automatic' will not enable an IOMMU since the Intel IOMMU device is not supported yet.\n"));
3379#endif
3380 }
3381 else
3382 {
3383 errorArgument(ModifyVM::tr("Invalid --iommu argument '%s'"), ValueUnion.psz);
3384 hrc = E_FAIL;
3385 }
3386 break;
3387 }
3388#endif
3389#if defined(VBOX_WITH_TPM)
3390 case MODIFYVM_TPM_TYPE:
3391 {
3392 ComPtr<ITrustedPlatformModule> tpm;
3393 sessionMachine->COMGETTER(TrustedPlatformModule)(tpm.asOutParam());
3394
3395 if ( !RTStrICmp(ValueUnion.psz, "none")
3396 || !RTStrICmp(ValueUnion.psz, "disabled"))
3397 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_None));
3398 else if (!RTStrICmp(ValueUnion.psz, "1.2"))
3399 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_v1_2));
3400 else if (!RTStrICmp(ValueUnion.psz, "2.0"))
3401 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_v2_0));
3402 else if (!RTStrICmp(ValueUnion.psz, "host"))
3403 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_Host));
3404 else if (!RTStrICmp(ValueUnion.psz, "swtpm"))
3405 CHECK_ERROR(tpm, COMSETTER(Type)(TpmType_Swtpm));
3406 else
3407 {
3408 errorArgument(ModifyVM::tr("Invalid --tpm-type argument '%s'"), ValueUnion.psz);
3409 hrc = E_FAIL;
3410 }
3411 break;
3412 }
3413
3414 case MODIFYVM_TPM_LOCATION:
3415 {
3416 ComPtr<ITrustedPlatformModule> tpm;
3417 sessionMachine->COMGETTER(TrustedPlatformModule)(tpm.asOutParam());
3418
3419 CHECK_ERROR(tpm, COMSETTER(Location)(Bstr(ValueUnion.psz).raw()));
3420 break;
3421 }
3422#endif
3423#ifdef VBOX_WITH_RECORDING
3424 case MODIFYVM_RECORDING:
3425 RT_FALL_THROUGH();
3426 case MODIFYVM_RECORDING_SCREENS:
3427 RT_FALL_THROUGH();
3428 case MODIFYVM_RECORDING_FILENAME:
3429 RT_FALL_THROUGH();
3430 case MODIFYVM_RECORDING_VIDEO_WIDTH:
3431 RT_FALL_THROUGH();
3432 case MODIFYVM_RECORDING_VIDEO_HEIGHT:
3433 RT_FALL_THROUGH();
3434 case MODIFYVM_RECORDING_VIDEO_RES:
3435 RT_FALL_THROUGH();
3436 case MODIFYVM_RECORDING_VIDEO_RATE:
3437 RT_FALL_THROUGH();
3438 case MODIFYVM_RECORDING_VIDEO_FPS:
3439 RT_FALL_THROUGH();
3440 case MODIFYVM_RECORDING_MAXTIME:
3441 RT_FALL_THROUGH();
3442 case MODIFYVM_RECORDING_MAXSIZE:
3443 RT_FALL_THROUGH();
3444 case MODIFYVM_RECORDING_OPTIONS:
3445 {
3446 ComPtr<IRecordingSettings> recordingSettings;
3447 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
3448 SafeIfaceArray <IRecordingScreenSettings> saRecordingScreenScreens;
3449 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordingScreenScreens)));
3450
3451 switch (c)
3452 {
3453 case MODIFYVM_RECORDING:
3454 {
3455 CHECK_ERROR(recordingSettings, COMSETTER(Enabled)(ValueUnion.f));
3456 break;
3457 }
3458 case MODIFYVM_RECORDING_SCREENS:
3459 {
3460 ULONG cMonitors = 64;
3461 CHECK_ERROR(pGraphicsAdapter, COMGETTER(MonitorCount)(&cMonitors));
3462 com::SafeArray<BOOL> screens(cMonitors);
3463 if (RT_FAILURE(parseScreens(ValueUnion.psz, &screens)))
3464 {
3465 errorArgument(ModifyVM::tr("Invalid list of screens specified\n"));
3466 hrc = E_FAIL;
3467 break;
3468 }
3469
3470 if (cMonitors > saRecordingScreenScreens.size()) /* Paranoia. */
3471 cMonitors = (ULONG)saRecordingScreenScreens.size();
3472
3473 for (size_t i = 0; i < cMonitors; ++i)
3474 CHECK_ERROR_BREAK(saRecordingScreenScreens[i], COMSETTER(Enabled)(screens[i]));
3475 break;
3476 }
3477 case MODIFYVM_RECORDING_FILENAME:
3478 {
3479 Bstr bstr;
3480 /* empty string will fall through, leaving bstr empty */
3481 if (*ValueUnion.psz)
3482 {
3483 char szVCFileAbs[RTPATH_MAX] = "";
3484 int vrc = RTPathAbs(ValueUnion.psz, szVCFileAbs, sizeof(szVCFileAbs));
3485 if (RT_FAILURE(vrc))
3486 {
3487 errorArgument(ModifyVM::tr("Cannot convert filename \"%s\" to absolute path\n"), ValueUnion.psz);
3488 hrc = E_FAIL;
3489 break;
3490 }
3491 bstr = szVCFileAbs;
3492 }
3493
3494 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3495 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Filename)(bstr.raw()));
3496 break;
3497 }
3498 case MODIFYVM_RECORDING_VIDEO_WIDTH:
3499 {
3500 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3501 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(ValueUnion.u32));
3502 break;
3503 }
3504 case MODIFYVM_RECORDING_VIDEO_HEIGHT:
3505 {
3506 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3507 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(ValueUnion.u32));
3508 break;
3509 }
3510 case MODIFYVM_RECORDING_VIDEO_RES:
3511 {
3512 uint32_t uWidth = 0;
3513 char *pszNext;
3514 int vrc = RTStrToUInt32Ex(ValueUnion.psz, &pszNext, 0, &uWidth);
3515 if (RT_FAILURE(vrc) || vrc != VWRN_TRAILING_CHARS || !pszNext || *pszNext != 'x')
3516 {
3517 errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
3518 ValueUnion.psz);
3519 hrc = E_FAIL;
3520 break;
3521 }
3522 uint32_t uHeight = 0;
3523 vrc = RTStrToUInt32Ex(pszNext+1, NULL, 0, &uHeight);
3524 if (vrc != VINF_SUCCESS)
3525 {
3526 errorArgument(ModifyVM::tr("Error parsing video resolution '%s' (expected <width>x<height>)"),
3527 ValueUnion.psz);
3528 hrc = E_FAIL;
3529 break;
3530 }
3531
3532 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3533 {
3534 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoWidth)(uWidth));
3535 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoHeight)(uHeight));
3536 }
3537 break;
3538 }
3539 case MODIFYVM_RECORDING_VIDEO_RATE:
3540 {
3541 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3542 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoRate)(ValueUnion.u32));
3543 break;
3544 }
3545 case MODIFYVM_RECORDING_VIDEO_FPS:
3546 {
3547 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3548 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(VideoFPS)(ValueUnion.u32));
3549 break;
3550 }
3551 case MODIFYVM_RECORDING_MAXTIME:
3552 {
3553 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3554 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxTime)(ValueUnion.u32));
3555 break;
3556 }
3557 case MODIFYVM_RECORDING_MAXSIZE:
3558 {
3559 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3560 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(MaxFileSize)(ValueUnion.u32));
3561 break;
3562 }
3563 case MODIFYVM_RECORDING_OPTIONS:
3564 {
3565 Bstr bstr(ValueUnion.psz);
3566 for (size_t i = 0; i < saRecordingScreenScreens.size(); ++i)
3567 CHECK_ERROR(saRecordingScreenScreens[i], COMSETTER(Options)(bstr.raw()));
3568 break;
3569 }
3570 }
3571
3572 break;
3573 }
3574#endif
3575 case MODIFYVM_AUTOSTART_ENABLED:
3576 {
3577 CHECK_ERROR(sessionMachine, COMSETTER(AutostartEnabled)(ValueUnion.f));
3578 break;
3579 }
3580
3581 case MODIFYVM_AUTOSTART_DELAY:
3582 {
3583 CHECK_ERROR(sessionMachine, COMSETTER(AutostartDelay)(ValueUnion.u32));
3584 break;
3585 }
3586
3587 case MODIFYVM_AUTOSTOP_TYPE:
3588 {
3589 AutostopType_T enmAutostopType = AutostopType_Disabled;
3590
3591 if (!RTStrICmp(ValueUnion.psz, "disabled"))
3592 enmAutostopType = AutostopType_Disabled;
3593 else if (!RTStrICmp(ValueUnion.psz, "savestate"))
3594 enmAutostopType = AutostopType_SaveState;
3595 else if (!RTStrICmp(ValueUnion.psz, "poweroff"))
3596 enmAutostopType = AutostopType_PowerOff;
3597 else if (!RTStrICmp(ValueUnion.psz, "acpishutdown"))
3598 enmAutostopType = AutostopType_AcpiShutdown;
3599 else
3600 {
3601 errorArgument(ModifyVM::tr("Invalid --autostop-type argument '%s' (valid: disabled, savestate, poweroff, acpishutdown)"),
3602 ValueUnion.psz);
3603 hrc = E_FAIL;
3604 }
3605
3606 if (SUCCEEDED(hrc))
3607 CHECK_ERROR(sessionMachine, COMSETTER(AutostopType)(enmAutostopType));
3608 break;
3609 }
3610#ifdef VBOX_WITH_PCI_PASSTHROUGH
3611 case MODIFYVM_ATTACH_PCI:
3612 {
3613 const char* pAt = strchr(ValueUnion.psz, '@');
3614 int32_t iHostAddr, iGuestAddr;
3615
3616 iHostAddr = parsePci(ValueUnion.psz);
3617 iGuestAddr = pAt != NULL ? parsePci(pAt + 1) : iHostAddr;
3618
3619 if (iHostAddr == -1 || iGuestAddr == -1)
3620 {
3621 errorArgument(ModifyVM::tr("Invalid --pciattach argument '%s' (valid: 'HB:HD.HF@GB:GD.GF' or just 'HB:HD.HF')"),
3622 ValueUnion.psz);
3623 hrc = E_FAIL;
3624 }
3625 else
3626 {
3627 CHECK_ERROR(sessionMachine, AttachHostPCIDevice(iHostAddr, iGuestAddr, TRUE));
3628 }
3629
3630 break;
3631 }
3632 case MODIFYVM_DETACH_PCI:
3633 {
3634 int32_t iHostAddr;
3635
3636 iHostAddr = parsePci(ValueUnion.psz);
3637 if (iHostAddr == -1)
3638 {
3639 errorArgument(ModifyVM::tr("Invalid --pcidetach argument '%s' (valid: 'HB:HD.HF')"), ValueUnion.psz);
3640 hrc = E_FAIL;
3641 }
3642 else
3643 {
3644 CHECK_ERROR(sessionMachine, DetachHostPCIDevice(iHostAddr));
3645 }
3646
3647 break;
3648 }
3649#endif
3650
3651#ifdef VBOX_WITH_USB_CARDREADER
3652 case MODIFYVM_USBCARDREADER:
3653 {
3654 CHECK_ERROR(sessionMachine, COMSETTER(EmulatedUSBCardReaderEnabled)(ValueUnion.f));
3655 break;
3656 }
3657#endif /* VBOX_WITH_USB_CARDREADER */
3658
3659 case MODIFYVM_DEFAULTFRONTEND:
3660 {
3661 Bstr bstr(ValueUnion.psz);
3662 if (bstr == "default")
3663 bstr = Bstr::Empty;
3664 CHECK_ERROR(sessionMachine, COMSETTER(DefaultFrontend)(bstr.raw()));
3665 break;
3666 }
3667
3668 case MODIFYVM_VMPROC_PRIORITY:
3669 {
3670 VMProcPriority_T enmPriority = nameToVMProcPriority(ValueUnion.psz);
3671 if (enmPriority == VMProcPriority_Invalid)
3672 {
3673 errorArgument(ModifyVM::tr("Invalid --vm-process-priority '%s'"), ValueUnion.psz);
3674 hrc = E_FAIL;
3675 }
3676 else
3677 {
3678 CHECK_ERROR(sessionMachine, COMSETTER(VMProcessPriority)(enmPriority));
3679 }
3680 break;
3681 }
3682
3683 case MODIFYVM_VMEXEC_ENGINE:
3684 {
3685 VMExecutionEngine_T enmExecEngine = nameToVMExecEngine(ValueUnion.psz);
3686 if (enmExecEngine == VMExecutionEngine_NotSet)
3687 {
3688 errorArgument(ModifyVM::tr("Invalid --vm-execution-engine '%s'"), ValueUnion.psz);
3689 hrc = E_FAIL;
3690 }
3691 else
3692 {
3693 CHECK_ERROR(sessionMachine, COMSETTER(VMExecutionEngine)(enmExecEngine));
3694 }
3695 break;
3696 }
3697
3698 case MODIFYVM_TESTING_ENABLED:
3699 hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingEnabled", ValueUnion.f ? "1" : "");
3700 break;
3701
3702 case MODIFYVM_TESTING_MMIO:
3703 hrc = setExtraData(sessionMachine, "VBoxInternal/Devices/VMMDev/0/Config/TestingMMIO", ValueUnion.f ? "1" : "");
3704 break;
3705
3706 case MODIFYVM_TESTING_CFG_DWORD:
3707 if (GetOptState.uIndex <= 9)
3708 {
3709 char szVar[128];
3710 RTStrPrintf(szVar, sizeof(szVar), "VBoxInternal/Devices/VMMDev/0/Config/TestingCfgDword%u",
3711 GetOptState.uIndex);
3712 char szValue[32];
3713 RTStrPrintf(szValue, sizeof(szValue), "%u", ValueUnion.u32);
3714 hrc = setExtraData(sessionMachine, szVar, szValue);
3715 }
3716 else
3717 hrc = errorArgumentHr(ModifyVM::tr("--testing-cfg-dword index %u is out of range: 0 thru 9"),
3718 GetOptState.uIndex);
3719 break;
3720
3721 case MODIFYVM_GUEST_DEBUG_PROVIDER:
3722 {
3723 ComPtr<IGuestDebugControl> gstDbgCtrl;
3724 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3725
3726 GuestDebugProvider_T enmDebugProvider = GuestDebugProvider_None;
3727
3728 if (!RTStrICmp(ValueUnion.psz, "none"))
3729 enmDebugProvider = GuestDebugProvider_None;
3730 else if (!RTStrICmp(ValueUnion.psz, "native"))
3731 enmDebugProvider = GuestDebugProvider_Native;
3732 else if (!RTStrICmp(ValueUnion.psz, "gdb"))
3733 enmDebugProvider = GuestDebugProvider_GDB;
3734 else if (!RTStrICmp(ValueUnion.psz, "kd"))
3735 enmDebugProvider = GuestDebugProvider_KD;
3736 else
3737 {
3738 errorArgument(ModifyVM::tr("Invalid --guest-debug-provider '%s' (valid: none, native, gdb, kd)"),
3739 ValueUnion.psz);
3740 hrc = E_FAIL;
3741 }
3742
3743 if (SUCCEEDED(hrc))
3744 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugProvider)(enmDebugProvider));
3745 break;
3746 }
3747
3748 case MODIFYVM_GUEST_DEBUG_IO_PROVIDER:
3749 {
3750 ComPtr<IGuestDebugControl> gstDbgCtrl;
3751 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3752
3753 GuestDebugIoProvider_T enmDebugIoProvider = GuestDebugIoProvider_None;
3754
3755 if (!RTStrICmp(ValueUnion.psz, "none"))
3756 enmDebugIoProvider = GuestDebugIoProvider_None;
3757 else if (!RTStrICmp(ValueUnion.psz, "tcp"))
3758 enmDebugIoProvider = GuestDebugIoProvider_TCP;
3759 else if (!RTStrICmp(ValueUnion.psz, "udp"))
3760 enmDebugIoProvider = GuestDebugIoProvider_UDP;
3761 else if (!RTStrICmp(ValueUnion.psz, "ipc"))
3762 enmDebugIoProvider = GuestDebugIoProvider_IPC;
3763 else
3764 {
3765 errorArgument(ModifyVM::tr("Invalid --guest-debug-io-provider '%s' (valid: none, tcp, udp, ipc)"),
3766 ValueUnion.psz);
3767 hrc = E_FAIL;
3768 }
3769
3770 if (SUCCEEDED(hrc))
3771 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugIoProvider)(enmDebugIoProvider));
3772 break;
3773 }
3774
3775 case MODIFYVM_GUEST_DEBUG_ADDRESS:
3776 {
3777 ComPtr<IGuestDebugControl> gstDbgCtrl;
3778 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3779
3780 Bstr bstr(ValueUnion.psz);
3781 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugAddress)(bstr.raw()));
3782 break;
3783 }
3784
3785 case MODIFYVM_GUEST_DEBUG_PORT:
3786 {
3787 ComPtr<IGuestDebugControl> gstDbgCtrl;
3788 CHECK_ERROR_BREAK(sessionMachine, COMGETTER(GuestDebugControl)(gstDbgCtrl.asOutParam()));
3789 CHECK_ERROR(gstDbgCtrl, COMSETTER(DebugPort)(ValueUnion.u32));
3790 break;
3791 }
3792
3793 default:
3794 {
3795 PlatformArchitecture_T enmArch;
3796 CHECK_ERROR_RET(platform, COMGETTER(Architecture)(&enmArch), RTEXITCODE_FAILURE);
3797
3798 if (enmArch == PlatformArchitecture_x86)
3799 {
3800 /* For the x86-based options we need the x86-specific platform object. */
3801 ComPtr<IPlatformX86> platformX86;
3802 CHECK_ERROR_RET(platform, COMGETTER(X86)(platformX86.asOutParam()), RTEXITCODE_FAILURE);
3803
3804 hrc = handleModifyVM_x86(&GetOptState, c, &ValueUnion, sessionMachine, platformX86);
3805 }
3806 else if (enmArch == PlatformArchitecture_ARM)
3807 {
3808 /* For the ARM-based options we need the x86-specific platform object. */
3809 ComPtr<IPlatformARM> platformARM;
3810 CHECK_ERROR_RET(platform, COMGETTER(ARM)(platformARM.asOutParam()), RTEXITCODE_FAILURE);
3811
3812 hrc = handleModifyVM_ARM(&GetOptState, c, &ValueUnion, sessionMachine, platformARM);
3813 }
3814 else
3815 {
3816 errorArgument(ModifyVM::tr("Invalid platform architecture returned for VM"));
3817 hrc = E_FAIL;
3818 }
3819
3820 if (FAILED(hrc))
3821 errorGetOpt(c, &ValueUnion);
3822 break;
3823 }
3824 }
3825 }
3826
3827 /* commit changes */
3828 if (SUCCEEDED(hrc))
3829 CHECK_ERROR(sessionMachine, SaveSettings());
3830
3831 /* it's important to always close sessions */
3832 a->session->UnlockMachine();
3833
3834 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3835}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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