VirtualBox

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

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

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use