VirtualBox

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

Last change on this file since 76678 was 76678, checked in by vboxsync, 5 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use