VirtualBox

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

Last change on this file since 81581 was 81581, checked in by vboxsync, 6 years ago

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

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