VirtualBox

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

最後變更 在這個檔案從92534是 92534,由 vboxsync 提交於 3 年 前

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

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