VirtualBox

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

Last change on this file since 82781 was 82681, checked in by vboxsync, 4 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use